lurf/area/
lurf/build/testing/
lurf/log/
lurf/player/
lurf/player/backup/
# 1 "comm.c"
 


















 













# 1 "/usr/include/glib-1.2/glib.h" 1 3
 


















 









 



































# 1 "/usr/lib/glib/include/glibconfig.h" 1
 







# 1 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/limits.h" 1 3
 


 





 
# 1 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/syslimits.h" 1 3
 





# 1 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/limits.h" 1 3
 


 

# 114 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/limits.h" 3



# 1 "/usr/include/limits.h" 1 3
 

















 






# 1 "/usr/include/features.h" 1 3
 




















 






























































 




















 





 



 







 
# 142 "/usr/include/features.h" 3


 









 








 



























# 208 "/usr/include/features.h" 3


































 



 


 








 




 
















 


# 1 "/usr/include/sys/cdefs.h" 1 3
 




















 




 






 





 








 



# 65 "/usr/include/sys/cdefs.h" 3


 





 




 









 







 

















 















 







 






 








 








 








 











 










 







 




 


















# 283 "/usr/include/features.h" 2 3



 








 





 

 








# 1 "/usr/include/gnu/stubs.h" 1 3
 



















# 312 "/usr/include/features.h" 2 3




# 26 "/usr/include/limits.h" 2 3



 





 

# 113 "/usr/include/limits.h" 3




  




# 140 "/usr/include/limits.h" 3



 
# 1 "/usr/include/bits/posix1_lim.h" 1 3
 

















 









 

 


 


 


 


 


 


 


 



 


 


 


 


 



 


 


 


 


 


 


 


 


 


 


 


 



 


 


 


 


 



 
# 1 "/usr/include/bits/local_lim.h" 1 3
 


















 














 
# 1 "/usr/include/linux/limits.h" 1 3



















# 36 "/usr/include/bits/local_lim.h" 2 3


 




 




 





 

 


 

 


 

 


 



 


 

# 126 "/usr/include/bits/posix1_lim.h" 2 3








 







# 144 "/usr/include/limits.h" 2 3




# 1 "/usr/include/bits/posix2_lim.h" 1 3
 

















 







 


 


 


 


 



 



 


 



 




 




























 



# 148 "/usr/include/limits.h" 2 3






# 117 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/limits.h" 2 3




# 7 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/syslimits.h" 2 3


# 11 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/limits.h" 2 3





 



 



 




 





 



 












 

 




 



 








 



 













 



# 107 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/limits.h" 3




 









# 9 "/usr/lib/glib/include/glibconfig.h" 2

# 1 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/float.h" 1 3
 



 

    


    


    


    


    


    


    


    


    


    


    



    


    


    


    


    


    


    


    


    



    


    


    



union __convert_long_double {
  unsigned __convert_long_double_i[4];
  long double __convert_long_double_d;
};


    


    


    


    


    


    




# 10 "/usr/lib/glib/include/glibconfig.h" 2


















typedef signed char gint8;
typedef unsigned char guint8;
typedef signed short gint16;
typedef unsigned short guint16;
typedef signed int gint32;
typedef unsigned int guint32;









__extension__  typedef signed long long gint64;
__extension__  typedef unsigned long long guint64;


































typedef struct _GStaticMutex GStaticMutex;
struct _GStaticMutex
{
  struct _GMutex *runtime_mutex;
  union {
    char   pad[24];
    double dummy_double;
    void  *dummy_pointer;
    long   dummy_long;
  } aligned_pad_u;
};










































# 66 "/usr/include/glib-1.2/glib.h" 2 3


 

# 1 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stdarg.h" 1 3
 
































































 






typedef void *__gnuc_va_list;



 



 

















void va_end (__gnuc_va_list);		 


 



 












 























 
 













# 175 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stdarg.h" 3


 




 

 

 

typedef __gnuc_va_list va_list;
























# 70 "/usr/include/glib-1.2/glib.h" 2 3


 






# 89 "/usr/include/glib-1.2/glib.h" 3



 






# 107 "/usr/include/glib-1.2/glib.h" 3









 





























 


# 157 "/usr/include/glib-1.2/glib.h" 3



 










 

















# 203 "/usr/include/glib-1.2/glib.h" 3



















 












# 243 "/usr/include/glib-1.2/glib.h" 3




 
























 










 









 











 





































 
















# 368 "/usr/include/glib-1.2/glib.h" 3









# 395 "/usr/include/glib-1.2/glib.h" 3















# 421 "/usr/include/glib-1.2/glib.h" 3


# 434 "/usr/include/glib-1.2/glib.h" 3

# 461 "/usr/include/glib-1.2/glib.h" 3





 






typedef char   gchar;
typedef short  gshort;
typedef long   glong;
typedef int    gint;
typedef gint   gboolean;

typedef unsigned char	guchar;
typedef unsigned short	gushort;
typedef unsigned long	gulong;
typedef unsigned int	guint;

typedef float	gfloat;
typedef double	gdouble;

 










typedef void* gpointer;
typedef const void *gconstpointer;


typedef gint32	gssize;
typedef guint32 gsize;
typedef guint32 GQuark;
typedef gint32	GTime;


 






	


 










 



# 542 "/usr/include/glib-1.2/glib.h" 3




# 557 "/usr/include/glib-1.2/glib.h" 3
# 568 "/usr/include/glib-1.2/glib.h" 3









# 593 "/usr/include/glib-1.2/glib.h" 3


# 609 "/usr/include/glib-1.2/glib.h" 3















 





























 







 













extern  const guint glib_major_version;
extern  const guint glib_minor_version;
extern  const guint glib_micro_version;
extern  const guint glib_interface_age;
extern  const guint glib_binary_age;







 

typedef struct _GAllocator	GAllocator;
typedef struct _GArray		GArray;
typedef struct _GByteArray	GByteArray;
typedef struct _GCache		GCache;
typedef struct _GCompletion	GCompletion;
typedef	struct _GData		GData;
typedef struct _GDebugKey	GDebugKey;
typedef struct _GHashTable	GHashTable;
typedef struct _GHook		GHook;
typedef struct _GHookList	GHookList;
typedef struct _GList		GList;
typedef struct _GMemChunk	GMemChunk;
typedef struct _GNode		GNode;
typedef struct _GPtrArray	GPtrArray;
typedef struct _GRelation	GRelation;
typedef struct _GScanner	GScanner;
typedef struct _GScannerConfig	GScannerConfig;
typedef struct _GSList		GSList;
typedef struct _GString		GString;
typedef struct _GStringChunk	GStringChunk;
typedef struct _GTimer		GTimer;
typedef struct _GTree		GTree;
typedef struct _GTuples		GTuples;
typedef union  _GTokenValue	GTokenValue;
typedef struct _GIOChannel	GIOChannel;

 
typedef enum
{
  G_TRAVERSE_LEAFS	= 1 << 0,
  G_TRAVERSE_NON_LEAFS	= 1 << 1,
  G_TRAVERSE_ALL	= G_TRAVERSE_LEAFS | G_TRAVERSE_NON_LEAFS,
  G_TRAVERSE_MASK	= 0x03
} GTraverseFlags;

 
typedef enum
{
  G_IN_ORDER,
  G_PRE_ORDER,
  G_POST_ORDER,
  G_LEVEL_ORDER
} GTraverseType;

 




 

typedef enum
{
   
  G_LOG_FLAG_RECURSION		= 1 << 0,
  G_LOG_FLAG_FATAL		= 1 << 1,
  
   
  G_LOG_LEVEL_ERROR		= 1 << 2,	 
  G_LOG_LEVEL_CRITICAL		= 1 << 3,
  G_LOG_LEVEL_WARNING		= 1 << 4,
  G_LOG_LEVEL_MESSAGE		= 1 << 5,
  G_LOG_LEVEL_INFO		= 1 << 6,
  G_LOG_LEVEL_DEBUG		= 1 << 7,
  
  G_LOG_LEVEL_MASK		= ~(G_LOG_FLAG_RECURSION | G_LOG_FLAG_FATAL)
} GLogLevelFlags;

 



typedef gpointer	(*GCacheNewFunc)	(gpointer	key);
typedef gpointer	(*GCacheDupFunc)	(gpointer	value);
typedef void		(*GCacheDestroyFunc)	(gpointer	value);
typedef gint		(*GCompareFunc)		(gconstpointer	a,
						 gconstpointer	b);
typedef gchar*		(*GCompletionFunc)	(gpointer);
typedef void		(*GDestroyNotify)	(gpointer	data);
typedef void		(*GDataForeachFunc)	(GQuark		key_id,
						 gpointer	data,
						 gpointer	user_data);
typedef void		(*GFunc)		(gpointer	data,
						 gpointer	user_data);
typedef guint		(*GHashFunc)		(gconstpointer	key);
typedef void		(*GFreeFunc)		(gpointer	data);
typedef void		(*GHFunc)		(gpointer	key,
						 gpointer	value,
						 gpointer	user_data);
typedef gboolean	(*GHRFunc)		(gpointer	key,
						 gpointer	value,
						 gpointer	user_data);
typedef gint		(*GHookCompareFunc)	(GHook		*new_hook,
						 GHook		*sibling);
typedef gboolean	(*GHookFindFunc)	(GHook		*hook,
						 gpointer	 data);
typedef void		(*GHookMarshaller)	(GHook		*hook,
						 gpointer	 data);
typedef gboolean	(*GHookCheckMarshaller)	(GHook		*hook,
						 gpointer	 data);
typedef void		(*GHookFunc)		(gpointer	 data);
typedef gboolean	(*GHookCheckFunc)	(gpointer	 data);
typedef void		(*GHookFreeFunc)	(GHookList      *hook_list,
						 GHook          *hook);
typedef void		(*GLogFunc)		(const gchar   *log_domain,
						 GLogLevelFlags	log_level,
						 const gchar   *message,
						 gpointer	user_data);
typedef gboolean	(*GNodeTraverseFunc)	(GNode	       *node,
						 gpointer	data);
typedef void		(*GNodeForeachFunc)	(GNode	       *node,
						 gpointer	data);
typedef gint		(*GSearchFunc)		(gpointer	key,
						 gpointer	data);
typedef void		(*GScannerMsgFunc)	(GScanner      *scanner,
						 gchar	       *message,
						 gint		error);
typedef gint		(*GTraverseFunc)	(gpointer	key,
						 gpointer	value,
						 gpointer	data);
typedef	void		(*GVoidFunc)		(void);


struct _GList
{
  gpointer data;
  GList *next;
  GList *prev;
};

struct _GSList
{
  gpointer data;
  GSList *next;
};

struct _GString
{
  gchar *str;
  gint len;
};

struct _GArray
{
  gchar *data;
  guint len;
};

struct _GByteArray
{
  guint8 *data;
  guint	  len;
};

struct _GPtrArray
{
  gpointer *pdata;
  guint	    len;
};

struct _GTuples
{
  guint len;
};

struct _GDebugKey
{
  gchar *key;
  guint	 value;
};


 

void   g_list_push_allocator    (GAllocator     *allocator);
void   g_list_pop_allocator     (void);
GList* g_list_alloc		(void);
void   g_list_free		(GList		*list);
void   g_list_free_1		(GList		*list);
GList* g_list_append		(GList		*list,
				 gpointer	 data);
GList* g_list_prepend		(GList		*list,
				 gpointer	 data);
GList* g_list_insert		(GList		*list,
				 gpointer	 data,
				 gint		 position);
GList* g_list_insert_sorted	(GList		*list,
				 gpointer	 data,
				 GCompareFunc	 func);
GList* g_list_concat		(GList		*list1,
				 GList		*list2);
GList* g_list_remove		(GList		*list,
				 gpointer	 data);
GList* g_list_remove_link	(GList		*list,
				 GList		*llink);
GList* g_list_reverse		(GList		*list);
GList* g_list_copy		(GList		*list);
GList* g_list_nth		(GList		*list,
				 guint		 n);
GList* g_list_find		(GList		*list,
				 gpointer	 data);
GList* g_list_find_custom	(GList		*list,
				 gpointer	 data,
				 GCompareFunc	 func);
gint   g_list_position		(GList		*list,
				 GList		*llink);
gint   g_list_index		(GList		*list,
				 gpointer	 data);
GList* g_list_last		(GList		*list);
GList* g_list_first		(GList		*list);
guint  g_list_length		(GList		*list);
void   g_list_foreach		(GList		*list,
				 GFunc		 func,
				 gpointer	 user_data);
GList* g_list_sort              (GList          *list,
		                 GCompareFunc    compare_func);
gpointer g_list_nth_data	(GList		*list,
				 guint		 n);




 

void    g_slist_push_allocator  (GAllocator     *allocator);
void    g_slist_pop_allocator   (void);
GSList* g_slist_alloc		(void);
void	g_slist_free		(GSList		*list);
void	g_slist_free_1		(GSList		*list);
GSList* g_slist_append		(GSList		*list,
				 gpointer	 data);
GSList* g_slist_prepend		(GSList		*list,
				 gpointer	 data);
GSList* g_slist_insert		(GSList		*list,
				 gpointer	 data,
				 gint		 position);
GSList* g_slist_insert_sorted	(GSList		*list,
				 gpointer	 data,
				 GCompareFunc	 func);
GSList* g_slist_concat		(GSList		*list1,
				 GSList		*list2);
GSList* g_slist_remove		(GSList		*list,
				 gpointer	 data);
GSList* g_slist_remove_link	(GSList		*list,
				 GSList		*llink);
GSList* g_slist_reverse		(GSList		*list);
GSList*	g_slist_copy		(GSList		*list);
GSList* g_slist_nth		(GSList		*list,
				 guint		 n);
GSList* g_slist_find		(GSList		*list,
				 gpointer	 data);
GSList* g_slist_find_custom	(GSList		*list,
				 gpointer	 data,
				 GCompareFunc	 func);
gint	g_slist_position	(GSList		*list,
				 GSList		*llink);
gint	g_slist_index		(GSList		*list,
				 gpointer	 data);
GSList* g_slist_last		(GSList		*list);
guint	g_slist_length		(GSList		*list);
void	g_slist_foreach		(GSList		*list,
				 GFunc		 func,
				 gpointer	 user_data);
GSList*  g_slist_sort           (GSList          *list,
		                 GCompareFunc    compare_func);
gpointer g_slist_nth_data	(GSList		*list,
				 guint		 n);



 

GHashTable* g_hash_table_new		(GHashFunc	 hash_func,
					 GCompareFunc	 key_compare_func);
void	    g_hash_table_destroy	(GHashTable	*hash_table);
void	    g_hash_table_insert		(GHashTable	*hash_table,
					 gpointer	 key,
					 gpointer	 value);
void	    g_hash_table_remove		(GHashTable	*hash_table,
					 gconstpointer	 key);
gpointer    g_hash_table_lookup		(GHashTable	*hash_table,
					 gconstpointer	 key);
gboolean    g_hash_table_lookup_extended(GHashTable	*hash_table,
					 gconstpointer	 lookup_key,
					 gpointer	*orig_key,
					 gpointer	*value);
void	    g_hash_table_freeze		(GHashTable	*hash_table);
void	    g_hash_table_thaw		(GHashTable	*hash_table);
void	    g_hash_table_foreach	(GHashTable	*hash_table,
					 GHFunc		 func,
					 gpointer	 user_data);
guint	    g_hash_table_foreach_remove	(GHashTable	*hash_table,
					 GHRFunc	 func,
					 gpointer	 user_data);
guint	    g_hash_table_size		(GHashTable	*hash_table);


 

GCache*	 g_cache_new	       (GCacheNewFunc	   value_new_func,
				GCacheDestroyFunc  value_destroy_func,
				GCacheDupFunc	   key_dup_func,
				GCacheDestroyFunc  key_destroy_func,
				GHashFunc	   hash_key_func,
				GHashFunc	   hash_value_func,
				GCompareFunc	   key_compare_func);
void	 g_cache_destroy       (GCache		  *cache);
gpointer g_cache_insert	       (GCache		  *cache,
				gpointer	   key);
void	 g_cache_remove	       (GCache		  *cache,
				gpointer	   value);
void	 g_cache_key_foreach   (GCache		  *cache,
				GHFunc		   func,
				gpointer	   user_data);
void	 g_cache_value_foreach (GCache		  *cache,
				GHFunc		   func,
				gpointer	   user_data);


 

GTree*	 g_tree_new	 (GCompareFunc	 key_compare_func);
void	 g_tree_destroy	 (GTree		*tree);
void	 g_tree_insert	 (GTree		*tree,
			  gpointer	 key,
			  gpointer	 value);
void	 g_tree_remove	 (GTree		*tree,
			  gpointer	 key);
gpointer g_tree_lookup	 (GTree		*tree,
			  gpointer	 key);
void	 g_tree_traverse (GTree		*tree,
			  GTraverseFunc	 traverse_func,
			  GTraverseType	 traverse_type,
			  gpointer	 data);
gpointer g_tree_search	 (GTree		*tree,
			  GSearchFunc	 search_func,
			  gpointer	 data);
gint	 g_tree_height	 (GTree		*tree);
gint	 g_tree_nnodes	 (GTree		*tree);



 

struct _GNode
{
  gpointer data;
  GNode	  *next;
  GNode	  *prev;
  GNode	  *parent;
  GNode	  *children;
};






void     g_node_push_allocator  (GAllocator       *allocator);
void     g_node_pop_allocator   (void);
GNode*	 g_node_new		(gpointer	   data);
void	 g_node_destroy		(GNode		  *root);
void	 g_node_unlink		(GNode		  *node);
GNode*	 g_node_insert		(GNode		  *parent,
				 gint		   position,
				 GNode		  *node);
GNode*	 g_node_insert_before	(GNode		  *parent,
				 GNode		  *sibling,
				 GNode		  *node);
GNode*	 g_node_prepend		(GNode		  *parent,
				 GNode		  *node);
guint	 g_node_n_nodes		(GNode		  *root,
				 GTraverseFlags	   flags);
GNode*	 g_node_get_root	(GNode		  *node);
gboolean g_node_is_ancestor	(GNode		  *node,
				 GNode		  *descendant);
guint	 g_node_depth		(GNode		  *node);
GNode*	 g_node_find		(GNode		  *root,
				 GTraverseType	   order,
				 GTraverseFlags	   flags,
				 gpointer	   data);

 











 




void	 g_node_traverse	(GNode		  *root,
				 GTraverseType	   order,
				 GTraverseFlags	   flags,
				 gint		   max_depth,
				 GNodeTraverseFunc func,
				 gpointer	   data);

 




guint	 g_node_max_height	 (GNode *root);

void	 g_node_children_foreach (GNode		  *node,
				  GTraverseFlags   flags,
				  GNodeForeachFunc func,
				  gpointer	   data);
void	 g_node_reverse_children (GNode		  *node);
guint	 g_node_n_children	 (GNode		  *node);
GNode*	 g_node_nth_child	 (GNode		  *node,
				  guint		   n);
GNode*	 g_node_last_child	 (GNode		  *node);
GNode*	 g_node_find_child	 (GNode		  *node,
				  GTraverseFlags   flags,
				  gpointer	   data);
gint	 g_node_child_position	 (GNode		  *node,
				  GNode		  *child);
gint	 g_node_child_index	 (GNode		  *node,
				  gpointer	   data);

GNode*	 g_node_first_sibling	 (GNode		  *node);
GNode*	 g_node_last_sibling	 (GNode		  *node);









 


typedef enum
{
  G_HOOK_FLAG_ACTIVE	= 1 << 0,
  G_HOOK_FLAG_IN_CALL	= 1 << 1,
  G_HOOK_FLAG_MASK	= 0x0f
} GHookFlagMask;



struct _GHookList
{
  guint		 seq_id;
  guint		 hook_size;
  guint		 is_setup : 1;
  GHook		*hooks;
  GMemChunk	*hook_memchunk;
  GHookFreeFunc	 hook_free;  
  GHookFreeFunc	 hook_destroy;  
};

struct _GHook
{
  gpointer	 data;
  GHook		*next;
  GHook		*prev;
  guint		 ref_count;
  guint		 hook_id;
  guint		 flags;
  gpointer	 func;
  GDestroyNotify destroy;
};












void	 g_hook_list_init		(GHookList		*hook_list,
					 guint			 hook_size);
void	 g_hook_list_clear		(GHookList		*hook_list);
GHook*	 g_hook_alloc			(GHookList		*hook_list);
void	 g_hook_free			(GHookList		*hook_list,
					 GHook			*hook);
void	 g_hook_ref			(GHookList		*hook_list,
					 GHook			*hook);
void	 g_hook_unref			(GHookList		*hook_list,
					 GHook			*hook);
gboolean g_hook_destroy			(GHookList		*hook_list,
					 guint			 hook_id);
void	 g_hook_destroy_link		(GHookList		*hook_list,
					 GHook			*hook);
void	 g_hook_prepend			(GHookList		*hook_list,
					 GHook			*hook);
void	 g_hook_insert_before		(GHookList		*hook_list,
					 GHook			*sibling,
					 GHook			*hook);
void	 g_hook_insert_sorted		(GHookList		*hook_list,
					 GHook			*hook,
					 GHookCompareFunc	 func);
GHook*	 g_hook_get			(GHookList		*hook_list,
					 guint			 hook_id);
GHook*	 g_hook_find			(GHookList		*hook_list,
					 gboolean		 need_valids,
					 GHookFindFunc		 func,
					 gpointer		 data);
GHook*	 g_hook_find_data		(GHookList		*hook_list,
					 gboolean		 need_valids,
					 gpointer		 data);
GHook*	 g_hook_find_func		(GHookList		*hook_list,
					 gboolean		 need_valids,
					 gpointer		 func);
GHook*	 g_hook_find_func_data		(GHookList		*hook_list,
					 gboolean		 need_valids,
					 gpointer		 func,
					 gpointer		 data);
 
GHook*	 g_hook_first_valid		(GHookList		*hook_list,
					 gboolean		 may_be_in_call);
 


GHook*	 g_hook_next_valid		(GHookList		*hook_list,
					 GHook			*hook,
					 gboolean		 may_be_in_call);

 
gint	 g_hook_compare_ids		(GHook			*new_hook,
					 GHook			*sibling);

 



 

void	 g_hook_list_invoke		(GHookList		*hook_list,
					 gboolean		 may_recurse);
 


void	 g_hook_list_invoke_check	(GHookList		*hook_list,
					 gboolean		 may_recurse);
 

void	 g_hook_list_marshal		(GHookList		*hook_list,
					 gboolean		 may_recurse,
					 GHookMarshaller	 marshaller,
					 gpointer		 data);
void	 g_hook_list_marshal_check	(GHookList		*hook_list,
					 gboolean		 may_recurse,
					 GHookCheckMarshaller	 marshaller,
					 gpointer		 data);


 








void g_on_error_query (const gchar *prg_name);
void g_on_error_stack_trace (const gchar *prg_name);


 

extern	        const gchar		*g_log_domain_glib;
guint		g_log_set_handler	(const gchar	*log_domain,
					 GLogLevelFlags	 log_levels,
					 GLogFunc	 log_func,
					 gpointer	 user_data);
void		g_log_remove_handler	(const gchar	*log_domain,
					 guint		 handler_id);
void		g_log_default_handler	(const gchar	*log_domain,
					 GLogLevelFlags	 log_level,
					 const gchar	*message,
					 gpointer	 unused_data);
void		g_log			(const gchar	*log_domain,
					 GLogLevelFlags	 log_level,
					 const gchar	*format,
					 ...) __attribute__((format (printf,  3 ,   4 ))) ;
void		g_logv			(const gchar	*log_domain,
					 GLogLevelFlags	 log_level,
					 const gchar	*format,
					 va_list	 args);
GLogLevelFlags	g_log_set_fatal_mask	(const gchar	*log_domain,
					 GLogLevelFlags	 fatal_mask);
GLogLevelFlags	g_log_set_always_fatal	(GLogLevelFlags	 fatal_mask);



# 1307 "/usr/include/glib-1.2/glib.h" 3













# 1348 "/usr/include/glib-1.2/glib.h" 3


typedef void	(*GPrintFunc)		(const gchar	*string);
void		g_print			(const gchar	*format,
					 ...) __attribute__((format (printf,  1 ,   2 ))) ;
GPrintFunc	g_set_print_handler	(GPrintFunc	 func);
void		g_printerr		(const gchar	*format,
					 ...) __attribute__((format (printf,  1 ,   2 ))) ;
GPrintFunc	g_set_printerr_handler	(GPrintFunc	 func);

 
typedef void		(*GErrorFunc)		(const gchar *str);
typedef void		(*GWarningFunc)		(const gchar *str);
GErrorFunc   g_set_error_handler   (GErrorFunc	 func);
GWarningFunc g_set_warning_handler (GWarningFunc func);
GPrintFunc   g_set_message_handler (GPrintFunc func);


 










gpointer g_malloc      (gulong	  size);
gpointer g_malloc0     (gulong	  size);
gpointer g_realloc     (gpointer  mem,
			gulong	  size);
void	 g_free	       (gpointer  mem);



void	 g_mem_profile (void);
void	 g_mem_check   (gpointer  mem);

 

GAllocator* g_allocator_new   (const gchar  *name,
			       guint         n_preallocs);
void        g_allocator_free  (GAllocator   *allocator);






 











 









GMemChunk* g_mem_chunk_new     (gchar	  *name,
				gint	   atom_size,
				gulong	   area_size,
				gint	   type);
void	   g_mem_chunk_destroy (GMemChunk *mem_chunk);
gpointer   g_mem_chunk_alloc   (GMemChunk *mem_chunk);
gpointer   g_mem_chunk_alloc0  (GMemChunk *mem_chunk);
void	   g_mem_chunk_free    (GMemChunk *mem_chunk,
				gpointer   mem);
void	   g_mem_chunk_clean   (GMemChunk *mem_chunk);
void	   g_mem_chunk_reset   (GMemChunk *mem_chunk);
void	   g_mem_chunk_print   (GMemChunk *mem_chunk);
void	   g_mem_chunk_info    (void);

 







void g_blow_chunks (void);


 

GTimer* g_timer_new	(void);
void	g_timer_destroy (GTimer	 *timer);
void	g_timer_start	(GTimer	 *timer);
void	g_timer_stop	(GTimer	 *timer);
void	g_timer_reset	(GTimer	 *timer);
gdouble g_timer_elapsed (GTimer	 *timer,
			 gulong	 *microseconds);


 



gchar*	 g_strdelimit		(gchar	     *string,
				 const gchar *delimiters,
				 gchar	      new_delimiter);
gdouble	 g_strtod		(const gchar *nptr,
				 gchar	    **endptr);
gchar*	 g_strerror		(gint	      errnum);
gchar*	 g_strsignal		(gint	      signum);
gint	 g_strcasecmp		(const gchar *s1,
				 const gchar *s2);
gint	 g_strncasecmp		(const gchar *s1,
				 const gchar *s2,
				 guint 	      n);
void	 g_strdown		(gchar	     *string);
void	 g_strup		(gchar	     *string);
void	 g_strreverse		(gchar	     *string);
 
gchar*   g_strchug              (gchar        *string);
 
gchar*  g_strchomp              (gchar        *string);
 


 


gchar*	 g_strdup		(const gchar *str);
gchar*	 g_strdup_printf	(const gchar *format,
				 ...) __attribute__((format (printf,  1 ,   2 ))) ;
gchar*	 g_strdup_vprintf	(const gchar *format,
				 va_list      args);
gchar*	 g_strndup		(const gchar *str,
				 guint	      n);
gchar*	 g_strnfill		(guint	      length,
				 gchar	      fill_char);
gchar*	 g_strconcat		(const gchar *string1,
				 ...);  
gchar*   g_strjoin		(const gchar  *separator,
				 ...);  
gchar*	 g_strescape		(gchar	      *string);
gpointer g_memdup		(gconstpointer mem,
				 guint	       byte_size);

 






gchar**	 g_strsplit		(const gchar  *string,
				 const gchar  *delimiter,
				 gint          max_tokens);
gchar*   g_strjoinv		(const gchar  *separator,
				 gchar       **str_array);
void     g_strfreev		(gchar       **str_array);



 

guint	g_printf_string_upper_bound (const gchar* format,
				     va_list	  args);


 

gchar*	g_get_user_name		(void);
gchar*	g_get_real_name		(void);
gchar*	g_get_home_dir		(void);
gchar*	g_get_tmp_dir		(void);
gchar*	g_get_prgname		(void);
void	g_set_prgname		(const gchar *prgname);


 

guint	g_parse_debug_string	(const gchar *string,
				 GDebugKey   *keys,
				 guint	      nkeys);
gint	g_snprintf		(gchar	     *string,
				 gulong	      n,
				 gchar const *format,
				 ...) __attribute__((format (printf,  3 ,   4 ))) ;
gint	g_vsnprintf		(gchar	     *string,
				 gulong	      n,
				 gchar const *format,
				 va_list      args);
gchar*	g_basename		(const gchar *file_name);
 
gboolean g_path_is_absolute	(const gchar *file_name);
 
gchar*  g_path_skip_root	(gchar       *file_name);

 
gchar*	g_dirname		(const gchar *file_name);
gchar*	g_get_current_dir	(void);

 

gchar*  g_getenv		(const gchar *variable);


 




void	g_atexit		(GVoidFunc    func);


 

extern inline  gint	g_bit_nth_lsf (guint32 mask,
				       gint    nth_bit);

extern inline  gint
g_bit_nth_lsf (guint32 mask,
	       gint    nth_bit)
{
  do
    {
      nth_bit++;
      if (mask & (1 << (guint) nth_bit))
	return nth_bit;
    }
  while (nth_bit < 32);
  return -1;
}


extern inline  gint	g_bit_nth_msf (guint32 mask,
				       gint    nth_bit);

extern inline  gint
g_bit_nth_msf (guint32 mask,
	       gint    nth_bit)
{
  if (nth_bit < 0)
    nth_bit = 32;
  do
    {
      nth_bit--;
      if (mask & (1 << (guint) nth_bit))
	return nth_bit;
    }
  while (nth_bit > 0);
  return -1;
}


extern inline  guint	g_bit_storage (guint number);

extern inline  guint
g_bit_storage (guint number)
{
  register guint n_bits = 0;
  
  do
    {
      n_bits++;
      number >>= 1;
    }
  while (number);
  return n_bits;
}


 

GStringChunk* g_string_chunk_new	   (gint size);
void	      g_string_chunk_free	   (GStringChunk *chunk);
gchar*	      g_string_chunk_insert	   (GStringChunk *chunk,
					    const gchar	 *string);
gchar*	      g_string_chunk_insert_const  (GStringChunk *chunk,
					    const gchar	 *string);


 

GString* g_string_new	    (const gchar *init);
GString* g_string_sized_new (guint	  dfl_size);
void	 g_string_free	    (GString	 *string,
			     gint	  free_segment);
GString* g_string_assign    (GString	 *lval,
			     const gchar *rval);
GString* g_string_truncate  (GString	 *string,
			     gint	  len);
GString* g_string_append    (GString	 *string,
			     const gchar *val);
GString* g_string_append_c  (GString	 *string,
			     gchar	  c);
GString* g_string_prepend   (GString	 *string,
			     const gchar *val);
GString* g_string_prepend_c (GString	 *string,
			     gchar	  c);
GString* g_string_insert    (GString	 *string,
			     gint	  pos,
			     const gchar *val);
GString* g_string_insert_c  (GString	 *string,
			     gint	  pos,
			     gchar	  c);
GString* g_string_erase	    (GString	 *string,
			     gint	  pos,
			     gint	  len);
GString* g_string_down	    (GString	 *string);
GString* g_string_up	    (GString	 *string);
void	 g_string_sprintf   (GString	 *string,
			     const gchar *format,
			     ...) __attribute__((format (printf,  2 ,   3 ))) ;
void	 g_string_sprintfa  (GString	 *string,
			     const gchar *format,
			     ...) __attribute__((format (printf,  2 ,   3 ))) ;


 









GArray* g_array_new	          (gboolean	    zero_terminated,
				   gboolean	    clear,
				   guint	    element_size);
void	g_array_free	          (GArray	   *array,
				   gboolean	    free_segment);
GArray* g_array_append_vals       (GArray	   *array,
				   gconstpointer    data,
				   guint	    len);
GArray* g_array_prepend_vals      (GArray	   *array,
				   gconstpointer    data,
				   guint	    len);
GArray* g_array_insert_vals       (GArray          *array,
				   guint            index,
				   gconstpointer    data,
				   guint            len);
GArray* g_array_set_size          (GArray	   *array,
				   guint	    length);
GArray* g_array_remove_index	  (GArray	   *array,
				   guint	    index);
GArray* g_array_remove_index_fast (GArray	   *array,
				   guint	    index);

 





GPtrArray*  g_ptr_array_new		   (void);
void	    g_ptr_array_free		   (GPtrArray	*array,
					    gboolean	 free_seg);
void	    g_ptr_array_set_size	   (GPtrArray	*array,
					    gint	 length);
gpointer    g_ptr_array_remove_index	   (GPtrArray	*array,
					    guint	 index);
gpointer    g_ptr_array_remove_index_fast  (GPtrArray	*array,
					    guint	 index);
gboolean    g_ptr_array_remove		   (GPtrArray	*array,
					    gpointer	 data);
gboolean    g_ptr_array_remove_fast        (GPtrArray	*array,
					    gpointer	 data);
void	    g_ptr_array_add		   (GPtrArray	*array,
					    gpointer	 data);

 



GByteArray* g_byte_array_new	           (void);
void	    g_byte_array_free	           (GByteArray	 *array,
					    gboolean	  free_segment);
GByteArray* g_byte_array_append	           (GByteArray	 *array,
					    const guint8 *data,
					    guint	  len);
GByteArray* g_byte_array_prepend           (GByteArray	 *array,
					    const guint8 *data,
					    guint	  len);
GByteArray* g_byte_array_set_size          (GByteArray	 *array,
					    guint	  length);
GByteArray* g_byte_array_remove_index	   (GByteArray	 *array,
					    guint	  index);
GByteArray* g_byte_array_remove_index_fast (GByteArray	 *array,
					    guint	  index);


 

gint  g_str_equal (gconstpointer   v,
		   gconstpointer   v2);
guint g_str_hash  (gconstpointer   v);

gint  g_int_equal (gconstpointer   v,
		   gconstpointer   v2);
guint g_int_hash  (gconstpointer   v);

 





guint g_direct_hash  (gconstpointer v);
gint  g_direct_equal (gconstpointer v,
		      gconstpointer v2);


 

GQuark	  g_quark_try_string		(const gchar	*string);
GQuark	  g_quark_from_static_string	(const gchar	*string);
GQuark	  g_quark_from_string		(const gchar	*string);
gchar*	  g_quark_to_string		(GQuark		 quark);


 


void	  g_datalist_init		 (GData		 **datalist);
void	  g_datalist_clear		 (GData		 **datalist);
gpointer  g_datalist_id_get_data	 (GData		 **datalist,
					  GQuark	   key_id);
void	  g_datalist_id_set_data_full	 (GData		 **datalist,
					  GQuark	   key_id,
					  gpointer	   data,
					  GDestroyNotify   destroy_func);
void	  g_datalist_id_remove_no_notify (GData		 **datalist,
					  GQuark	   key_id);
void	  g_datalist_foreach		 (GData		 **datalist,
					  GDataForeachFunc func,
					  gpointer	   user_data);
















 


void	  g_dataset_destroy		(gconstpointer	  dataset_location);
gpointer  g_dataset_id_get_data		(gconstpointer	  dataset_location,
					 GQuark		  key_id);
void	  g_dataset_id_set_data_full	(gconstpointer	  dataset_location,
					 GQuark		  key_id,
					 gpointer	  data,
					 GDestroyNotify	  destroy_func);
void	  g_dataset_id_remove_no_notify	(gconstpointer	  dataset_location,
					 GQuark		  key_id);
void	  g_dataset_foreach		(gconstpointer	  dataset_location,
					 GDataForeachFunc func,
					 gpointer	  user_data);
















 


 











 
typedef enum
{
  G_ERR_UNKNOWN,
  G_ERR_UNEXP_EOF,
  G_ERR_UNEXP_EOF_IN_STRING,
  G_ERR_UNEXP_EOF_IN_COMMENT,
  G_ERR_NON_DIGIT_IN_CONST,
  G_ERR_DIGIT_RADIX,
  G_ERR_FLOAT_RADIX,
  G_ERR_FLOAT_MALFORMED
} GErrorType;

 
typedef enum
{
  G_TOKEN_EOF			=   0,
  
  G_TOKEN_LEFT_PAREN		= '(',
  G_TOKEN_RIGHT_PAREN		= ')',
  G_TOKEN_LEFT_CURLY		= '{',
  G_TOKEN_RIGHT_CURLY		= '}',
  G_TOKEN_LEFT_BRACE		= '[',
  G_TOKEN_RIGHT_BRACE		= ']',
  G_TOKEN_EQUAL_SIGN		= '=',
  G_TOKEN_COMMA			= ',',
  
  G_TOKEN_NONE			= 256,
  
  G_TOKEN_ERROR,
  
  G_TOKEN_CHAR,
  G_TOKEN_BINARY,
  G_TOKEN_OCTAL,
  G_TOKEN_INT,
  G_TOKEN_HEX,
  G_TOKEN_FLOAT,
  G_TOKEN_STRING,
  
  G_TOKEN_SYMBOL,
  G_TOKEN_IDENTIFIER,
  G_TOKEN_IDENTIFIER_NULL,
  
  G_TOKEN_COMMENT_SINGLE,
  G_TOKEN_COMMENT_MULTI,
  G_TOKEN_LAST
} GTokenType;

union	_GTokenValue
{
  gpointer	v_symbol;
  gchar		*v_identifier;
  gulong	v_binary;
  gulong	v_octal;
  gulong	v_int;
  gdouble	v_float;
  gulong	v_hex;
  gchar		*v_string;
  gchar		*v_comment;
  guchar	v_char;
  guint		v_error;
};

struct	_GScannerConfig
{
   

  gchar		*cset_skip_characters;		 
  gchar		*cset_identifier_first;
  gchar		*cset_identifier_nth;
  gchar		*cpair_comment_single;		 
  
   

  guint		case_sensitive : 1;
  
   


  guint		skip_comment_multi : 1;		 
  guint		skip_comment_single : 1;	 
  guint		scan_comment_multi : 1;		 
  guint		scan_identifier : 1;
  guint		scan_identifier_1char : 1;
  guint		scan_identifier_NULL : 1;
  guint		scan_symbols : 1;
  guint		scan_binary : 1;
  guint		scan_octal : 1;
  guint		scan_float : 1;
  guint		scan_hex : 1;			 
  guint		scan_hex_dollar : 1;		 
  guint		scan_string_sq : 1;		 
  guint		scan_string_dq : 1;		 
  guint		numbers_2_int : 1;		 
  guint		int_2_float : 1;		 
  guint		identifier_2_string : 1;
  guint		char_2_token : 1;		 
  guint		symbol_2_token : 1;
  guint		scope_0_fallback : 1;		 
};

struct	_GScanner
{
   
  gpointer		user_data;
  guint			max_parse_errors;
  
   
  guint			parse_errors;
  
   
  const gchar		*input_name;
  
   
  gpointer		derived_data;
  
   
  GScannerConfig	*config;
  
   
  GTokenType		token;
  GTokenValue		value;
  guint			line;
  guint			position;
  
   
  GTokenType		next_token;
  GTokenValue		next_value;
  guint			next_line;
  guint			next_position;
  
   
  GHashTable		*symbol_table;
  gint			input_fd;
  const gchar		*text;
  const gchar		*text_end;
  gchar			*buffer;
  guint			scope_id;
  
   
  GScannerMsgFunc	msg_handler;
};

GScanner*	g_scanner_new			(GScannerConfig *config_templ);
void		g_scanner_destroy		(GScanner	*scanner);
void		g_scanner_input_file		(GScanner	*scanner,
						 gint		input_fd);
void		g_scanner_sync_file_offset	(GScanner	*scanner);
void		g_scanner_input_text		(GScanner	*scanner,
						 const	gchar	*text,
						 guint		text_len);
GTokenType	g_scanner_get_next_token	(GScanner	*scanner);
GTokenType	g_scanner_peek_next_token	(GScanner	*scanner);
GTokenType	g_scanner_cur_token		(GScanner	*scanner);
GTokenValue	g_scanner_cur_value		(GScanner	*scanner);
guint		g_scanner_cur_line		(GScanner	*scanner);
guint		g_scanner_cur_position		(GScanner	*scanner);
gboolean	g_scanner_eof			(GScanner	*scanner);
guint		g_scanner_set_scope		(GScanner	*scanner,
						 guint		 scope_id);
void		g_scanner_scope_add_symbol	(GScanner	*scanner,
						 guint		 scope_id,
						 const gchar	*symbol,
						 gpointer	value);
void		g_scanner_scope_remove_symbol	(GScanner	*scanner,
						 guint		 scope_id,
						 const gchar	*symbol);
gpointer	g_scanner_scope_lookup_symbol	(GScanner	*scanner,
						 guint		 scope_id,
						 const gchar	*symbol);
void		g_scanner_scope_foreach_symbol	(GScanner	*scanner,
						 guint		 scope_id,
						 GHFunc		 func,
						 gpointer	 user_data);
gpointer	g_scanner_lookup_symbol		(GScanner	*scanner,
						 const gchar	*symbol);
void		g_scanner_freeze_symbol_table	(GScanner	*scanner);
void		g_scanner_thaw_symbol_table	(GScanner	*scanner);
void		g_scanner_unexp_token		(GScanner	*scanner,
						 GTokenType	expected_token,
						 const gchar	*identifier_spec,
						 const gchar	*symbol_spec,
						 const gchar	*symbol_name,
						 const gchar	*message,
						 gint		 is_error);
void		g_scanner_error			(GScanner	*scanner,
						 const gchar	*format,
						 ...) __attribute__((format (printf,  2 ,  3 ))) ;
void		g_scanner_warn			(GScanner	*scanner,
						 const gchar	*format,
						 ...) __attribute__((format (printf,  2 ,  3 ))) ;
gint		g_scanner_stat_mode		(const gchar	*filename);
 











 


struct _GCompletion
{
  GList* items;
  GCompletionFunc func;
  
  gchar* prefix;
  GList* cache;
};

GCompletion* g_completion_new	       (GCompletionFunc func);
void	     g_completion_add_items    (GCompletion*	cmp,
					GList*		items);
void	     g_completion_remove_items (GCompletion*	cmp,
					GList*		items);
void	     g_completion_clear_items  (GCompletion*	cmp);
GList*	     g_completion_complete     (GCompletion*	cmp,
					gchar*		prefix,
					gchar**		new_prefix);
void	     g_completion_free	       (GCompletion*	cmp);


 








typedef guint16 GDateYear;
typedef guint8  GDateDay;    
typedef struct _GDate GDate;
 
struct tm;

 
typedef enum
{
  G_DATE_DAY   = 0,
  G_DATE_MONTH = 1,
  G_DATE_YEAR  = 2
} GDateDMY;

 
typedef enum
{
  G_DATE_BAD_WEEKDAY  = 0,
  G_DATE_MONDAY       = 1,
  G_DATE_TUESDAY      = 2,
  G_DATE_WEDNESDAY    = 3,
  G_DATE_THURSDAY     = 4,
  G_DATE_FRIDAY       = 5,
  G_DATE_SATURDAY     = 6,
  G_DATE_SUNDAY       = 7
} GDateWeekday;
typedef enum
{
  G_DATE_BAD_MONTH = 0,
  G_DATE_JANUARY   = 1,
  G_DATE_FEBRUARY  = 2,
  G_DATE_MARCH     = 3,
  G_DATE_APRIL     = 4,
  G_DATE_MAY       = 5,
  G_DATE_JUNE      = 6,
  G_DATE_JULY      = 7,
  G_DATE_AUGUST    = 8,
  G_DATE_SEPTEMBER = 9,
  G_DATE_OCTOBER   = 10,
  G_DATE_NOVEMBER  = 11,
  G_DATE_DECEMBER  = 12
} GDateMonth;





 




struct _GDate
{ 
  guint julian_days : 32;  





  guint julian : 1;     
  guint dmy    : 1;     

   
  guint day    : 6;  
  guint month  : 4; 
  guint year   : 16; 
};

 



GDate*       g_date_new                   (void);
GDate*       g_date_new_dmy               (GDateDay     day, 
                                           GDateMonth   month, 
                                           GDateYear    year);
GDate*       g_date_new_julian            (guint32      julian_day);
void         g_date_free                  (GDate       *date);

 




gboolean     g_date_valid                 (GDate       *date);
gboolean     g_date_valid_day             (GDateDay     day);
gboolean     g_date_valid_month           (GDateMonth   month);
gboolean     g_date_valid_year            (GDateYear    year);
gboolean     g_date_valid_weekday         (GDateWeekday weekday);
gboolean     g_date_valid_julian          (guint32      julian_date);
gboolean     g_date_valid_dmy             (GDateDay     day,
                                           GDateMonth   month,
                                           GDateYear    year);

GDateWeekday g_date_weekday               (GDate       *date);
GDateMonth   g_date_month                 (GDate       *date);
GDateYear    g_date_year                  (GDate       *date);
GDateDay     g_date_day                   (GDate       *date);
guint32      g_date_julian                (GDate       *date);
guint        g_date_day_of_year           (GDate       *date);

 





guint        g_date_monday_week_of_year   (GDate      *date);
guint        g_date_sunday_week_of_year   (GDate      *date);

 



void         g_date_clear                 (GDate       *date, 
                                           guint        n_dates);

 



void         g_date_set_parse             (GDate       *date,
                                           const gchar *str);
void         g_date_set_time              (GDate       *date, 
                                           GTime        time);
void         g_date_set_month             (GDate       *date, 
                                           GDateMonth   month);
void         g_date_set_day               (GDate       *date, 
                                           GDateDay     day);
void         g_date_set_year              (GDate       *date,
                                           GDateYear    year);
void         g_date_set_dmy               (GDate       *date,
                                           GDateDay     day,
                                           GDateMonth   month,
                                           GDateYear    y);
void         g_date_set_julian            (GDate       *date,
                                           guint32      julian_date);
gboolean     g_date_is_first_of_month     (GDate       *date);
gboolean     g_date_is_last_of_month      (GDate       *date);

 
void         g_date_add_days              (GDate       *date, 
                                           guint        n_days);
void         g_date_subtract_days         (GDate       *date, 
                                           guint        n_days);

 
void         g_date_add_months            (GDate       *date,
                                           guint        n_months);
void         g_date_subtract_months       (GDate       *date,
                                           guint        n_months);

 
void         g_date_add_years             (GDate       *date,
                                           guint        n_years);
void         g_date_subtract_years        (GDate       *date,
                                           guint        n_years);
gboolean     g_date_is_leap_year          (GDateYear    year);
guint8       g_date_days_in_month         (GDateMonth   month, 
                                           GDateYear    year);
guint8       g_date_monday_weeks_in_year  (GDateYear    year);
guint8       g_date_sunday_weeks_in_year  (GDateYear    year);

 
gint         g_date_compare               (GDate       *lhs,
                                           GDate       *rhs);
void         g_date_to_struct_tm          (GDate       *date,
                                           struct tm   *tm);

 


gsize        g_date_strftime              (gchar       *s,
                                           gsize        slen,
                                           const gchar *format,
                                           GDate       *date);


 






















GRelation* g_relation_new     (gint	    fields);
void	   g_relation_destroy (GRelation   *relation);
void	   g_relation_index   (GRelation   *relation,
			       gint	    field,
			       GHashFunc    hash_func,
			       GCompareFunc key_compare_func);
void	   g_relation_insert  (GRelation   *relation,
			       ...);
gint	   g_relation_delete  (GRelation   *relation,
			       gconstpointer  key,
			       gint	    field);
GTuples*   g_relation_select  (GRelation   *relation,
			       gconstpointer  key,
			       gint	    field);
gint	   g_relation_count   (GRelation   *relation,
			       gconstpointer  key,
			       gint	    field);
gboolean   g_relation_exists  (GRelation   *relation,
			       ...);
void	   g_relation_print   (GRelation   *relation);

void	   g_tuples_destroy   (GTuples	   *tuples);
gpointer   g_tuples_index     (GTuples	   *tuples,
			       gint	    index,
			       gint	    field);


 


 





guint	   g_spaced_primes_closest (guint num);


 


typedef struct _GIOFuncs GIOFuncs;
typedef enum
{
  G_IO_ERROR_NONE,
  G_IO_ERROR_AGAIN,
  G_IO_ERROR_INVAL,
  G_IO_ERROR_UNKNOWN
} GIOError;
typedef enum
{
  G_SEEK_CUR,
  G_SEEK_SET,
  G_SEEK_END
} GSeekType;
typedef enum
{
  G_IO_IN	=1 ,
  G_IO_OUT	=4 ,
  G_IO_PRI	=2 ,
  G_IO_ERR	=8 ,
  G_IO_HUP	=16 ,
  G_IO_NVAL	=32 
} GIOCondition;

struct _GIOChannel
{
  guint channel_flags;
  guint ref_count;
  GIOFuncs *funcs;
};

typedef gboolean (*GIOFunc) (GIOChannel   *source,
			     GIOCondition  condition,
			     gpointer      data);
struct _GIOFuncs
{
  GIOError (*io_read)   (GIOChannel 	*channel, 
		         gchar      	*buf, 
		         guint      	 count,
			 guint      	*bytes_read);
  GIOError (*io_write)  (GIOChannel 	*channel, 
		 	 gchar      	*buf, 
			 guint      	 count,
			 guint      	*bytes_written);
  GIOError (*io_seek)   (GIOChannel   	*channel, 
		 	 gint       	 offset, 
		  	 GSeekType  	 type);
  void (*io_close)      (GIOChannel	*channel);
  guint (*io_add_watch) (GIOChannel     *channel,
			 gint            priority,
			 GIOCondition    condition,
			 GIOFunc         func,
			 gpointer        user_data,
			 GDestroyNotify  notify);
  void (*io_free)       (GIOChannel	*channel);
};

void        g_io_channel_init   (GIOChannel    *channel);
void        g_io_channel_ref    (GIOChannel    *channel);
void        g_io_channel_unref  (GIOChannel    *channel);
GIOError    g_io_channel_read   (GIOChannel    *channel, 
			         gchar         *buf, 
			         guint          count,
			         guint         *bytes_read);
GIOError  g_io_channel_write    (GIOChannel    *channel, 
			         gchar         *buf, 
			         guint          count,
			         guint         *bytes_written);
GIOError  g_io_channel_seek     (GIOChannel    *channel,
			         gint           offset, 
			         GSeekType      type);
void      g_io_channel_close    (GIOChannel    *channel);
guint     g_io_add_watch_full   (GIOChannel    *channel,
			         gint           priority,
			         GIOCondition   condition,
			         GIOFunc        func,
			         gpointer       user_data,
			         GDestroyNotify notify);
guint    g_io_add_watch         (GIOChannel    *channel,
			         GIOCondition   condition,
			         GIOFunc        func,
			         gpointer       user_data);


 

typedef struct _GTimeVal	GTimeVal;
typedef struct _GSourceFuncs	GSourceFuncs;
typedef struct _GMainLoop	GMainLoop;	 

struct _GTimeVal
{
  glong tv_sec;
  glong tv_usec;
};
struct _GSourceFuncs
{
  gboolean (*prepare)  (gpointer  source_data, 
			GTimeVal *current_time,
			gint     *timeout,
			gpointer  user_data);
  gboolean (*check)    (gpointer  source_data,
			GTimeVal *current_time,
			gpointer  user_data);
  gboolean (*dispatch) (gpointer  source_data, 
			GTimeVal *dispatch_time,
			gpointer  user_data);
  GDestroyNotify destroy;
};

 







typedef gboolean (*GSourceFunc) (gpointer data);

 
guint    g_source_add                        (gint           priority, 
					      gboolean       can_recurse,
					      GSourceFuncs  *funcs,
					      gpointer       source_data, 
					      gpointer       user_data,
					      GDestroyNotify notify);
gboolean g_source_remove                     (guint          tag);
gboolean g_source_remove_by_user_data        (gpointer       user_data);
gboolean g_source_remove_by_source_data      (gpointer       source_data);
gboolean g_source_remove_by_funcs_user_data  (GSourceFuncs  *funcs,
					      gpointer       user_data);

void g_get_current_time		        (GTimeVal	*result);

 
GMainLoop*	g_main_new		(gboolean	 is_running);
void		g_main_run		(GMainLoop	*loop);
void		g_main_quit		(GMainLoop	*loop);
void		g_main_destroy		(GMainLoop	*loop);
gboolean	g_main_is_running	(GMainLoop	*loop);

 


gboolean	g_main_iteration	(gboolean	may_block);

 
gboolean	g_main_pending		(void);

 
guint		g_timeout_add_full	(gint           priority,
					 guint          interval, 
					 GSourceFunc    function,
					 gpointer       data,
					 GDestroyNotify notify);
guint		g_timeout_add		(guint          interval,
					 GSourceFunc    function,
					 gpointer       data);
guint		g_idle_add	   	(GSourceFunc	function,
					 gpointer	data);
guint	   	g_idle_add_full		(gint   	priority,
					 GSourceFunc	function,
					 gpointer	data,
					 GDestroyNotify destroy);
gboolean	g_idle_remove_by_data	(gpointer	data);

 























typedef struct _GPollFD GPollFD;
typedef gint	(*GPollFunc)	(GPollFD *ufds,
				 guint	  nfsd,
				 gint     timeout);
struct _GPollFD
{
  gint		fd;
  gushort 	events;
  gushort 	revents;
};

void        g_main_add_poll          (GPollFD    *fd,
				      gint        priority);
void        g_main_remove_poll       (GPollFD    *fd);
void        g_main_set_poll_func     (GPollFunc   func);

 










GIOChannel* g_io_channel_unix_new    (int         fd);
gint        g_io_channel_unix_get_fd (GIOChannel *channel);

# 2613 "/usr/include/glib-1.2/glib.h" 3


 

# 2672 "/usr/include/glib-1.2/glib.h" 3



 

typedef struct _GMutex		GMutex;
typedef struct _GCond		GCond;
typedef struct _GPrivate	GPrivate;
typedef struct _GStaticPrivate	GStaticPrivate;
typedef struct _GThreadFunctions GThreadFunctions;
struct _GThreadFunctions
{
  GMutex*  (*mutex_new)       (void);
  void     (*mutex_lock)      (GMutex		*mutex);
  gboolean (*mutex_trylock)   (GMutex		*mutex);
  void     (*mutex_unlock)    (GMutex		*mutex);
  void     (*mutex_free)      (GMutex		*mutex);
  GCond*   (*cond_new)        (void);
  void     (*cond_signal)     (GCond		*cond);
  void     (*cond_broadcast)  (GCond		*cond);
  void     (*cond_wait)       (GCond		*cond,
			       GMutex		*mutex);
  gboolean (*cond_timed_wait) (GCond		*cond,
			       GMutex		*mutex, 
			       GTimeVal 	*end_time);
  void      (*cond_free)      (GCond		*cond);
  GPrivate* (*private_new)    (GDestroyNotify	 destructor);
  gpointer  (*private_get)    (GPrivate		*private_key);
  void      (*private_set)    (GPrivate		*private_key,
			       gpointer		 data);
};

extern  GThreadFunctions	g_thread_functions_for_glib_use;
extern  gboolean		g_thread_use_default_impl;
extern  gboolean		g_threads_got_initialized;

 



void   g_thread_init   (GThreadFunctions       *vtable);

 
GMutex*	g_static_mutex_get_mutex_impl	(GMutex	**mutex);

 




 


























 










struct _GStaticPrivate
{
  guint index;
};

gpointer g_static_private_get (GStaticPrivate	*private_key);
void     g_static_private_set (GStaticPrivate	*private_key, 
			       gpointer        	 data,
			       GDestroyNotify    notify);

 








extern void glib_dummy_decl (void);







# 2808 "/usr/include/glib-1.2/glib.h" 3




















# 34 "comm.c" 2





# 1 "/usr/include/sys/types.h" 1 3
 

















 








 

# 1 "/usr/include/bits/types.h" 1 3
 

















 









# 1 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 1 3






 


# 19 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3



 


 





 


# 61 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 





 


















 





 

 

# 131 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 


































typedef unsigned int size_t;






















 




 

# 271 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


# 283 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 

# 317 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3




 





















# 29 "/usr/include/bits/types.h" 2 3


 
typedef unsigned char __u_char;
typedef unsigned short __u_short;
typedef unsigned int __u_int;
typedef unsigned long __u_long;

__extension__ typedef unsigned long long int __u_quad_t;
__extension__ typedef long long int __quad_t;
# 48 "/usr/include/bits/types.h" 3

typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;

__extension__ typedef signed long long int __int64_t;
__extension__ typedef unsigned long long int __uint64_t;

typedef __quad_t *__qaddr_t;

typedef __u_quad_t __dev_t;		 
typedef __u_int __uid_t;		 
typedef __u_int __gid_t;		 
typedef __u_long __ino_t;		 
typedef __u_int __mode_t;		 
typedef __u_int __nlink_t; 		 
typedef long int __off_t;		 
typedef __quad_t __loff_t;		 
typedef int __pid_t;			 
typedef int __ssize_t;			 
typedef __u_long __rlim_t;		 
typedef __u_quad_t __rlim64_t;		 
typedef __u_int __id_t;			 

typedef struct
  {
    int __val[2];
  } __fsid_t;				 

 
typedef int __daddr_t;			 
typedef char *__caddr_t;
typedef long int __time_t;
typedef unsigned int __useconds_t;
typedef long int __suseconds_t;
typedef long int __swblk_t;		 

typedef long int __clock_t;

 
typedef int __clockid_t;

 
typedef int __timer_t;


 



typedef int __key_t;

 
typedef unsigned short int __ipc_pid_t;


 
typedef long int __blksize_t;

 

 
typedef long int __blkcnt_t;
typedef __quad_t __blkcnt64_t;

 
typedef __u_long __fsblkcnt_t;
typedef __u_quad_t __fsblkcnt64_t;

 
typedef __u_long __fsfilcnt_t;
typedef __u_quad_t __fsfilcnt64_t;

 
typedef __u_quad_t __ino64_t;

 
typedef __loff_t __off64_t;

 
typedef long int __t_scalar_t;
typedef unsigned long int __t_uscalar_t;

 
typedef int __intptr_t;

 
typedef unsigned int __socklen_t;


 

# 1 "/usr/include/bits/pthreadtypes.h" 1 3
 
 
 
 
 
 
 
 
 
 
 
 
 









# 1 "/usr/include/bits/sched.h" 1 3
 



















# 62 "/usr/include/bits/sched.h" 3





 
struct __sched_param
  {
    int __sched_priority;
  };


# 23 "/usr/include/bits/pthreadtypes.h" 2 3


 
struct _pthread_fastlock
{
  long int __status;    
  int __spinlock;       

};


 
typedef struct _pthread_descr_struct *_pthread_descr;




 
typedef struct __pthread_attr_s
{
  int __detachstate;
  int __schedpolicy;
  struct __sched_param __schedparam;
  int __inheritsched;
  int __scope;
  size_t __guardsize;
  int __stackaddr_set;
  void *__stackaddr;
  size_t __stacksize;
} pthread_attr_t;


 
typedef struct
{
  struct _pthread_fastlock __c_lock;  
  _pthread_descr __c_waiting;         
} pthread_cond_t;


 
typedef struct
{
  int __dummy;
} pthread_condattr_t;

 
typedef unsigned int pthread_key_t;


 
 

typedef struct
{
  int __m_reserved;                
  int __m_count;                   
  _pthread_descr __m_owner;        
  int __m_kind;                    
  struct _pthread_fastlock __m_lock;  
} pthread_mutex_t;


 
typedef struct
{
  int __mutexkind;
} pthread_mutexattr_t;


 
typedef int pthread_once_t;


# 117 "/usr/include/bits/pthreadtypes.h" 3


# 136 "/usr/include/bits/pthreadtypes.h" 3



 
typedef unsigned long int pthread_t;


# 143 "/usr/include/bits/types.h" 2 3




# 30 "/usr/include/sys/types.h" 2 3




typedef __u_char u_char;
typedef __u_short u_short;
typedef __u_int u_int;
typedef __u_long u_long;
typedef __quad_t quad_t;
typedef __u_quad_t u_quad_t;
typedef __fsid_t fsid_t;




typedef __loff_t loff_t;



typedef __ino_t ino_t;











typedef __dev_t dev_t;




typedef __gid_t gid_t;




typedef __mode_t mode_t;




typedef __nlink_t nlink_t;




typedef __uid_t uid_t;





typedef __off_t off_t;











typedef __pid_t pid_t;




typedef __id_t id_t;




typedef __ssize_t ssize_t;





typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;





typedef __key_t key_t;









# 1 "/usr/include/time.h" 1 3
 

















 














# 51 "/usr/include/time.h" 3


# 61 "/usr/include/time.h" 3








 
typedef __time_t time_t;










 
typedef __clockid_t clockid_t;










 
typedef __timer_t timer_t;





# 112 "/usr/include/time.h" 3




# 364 "/usr/include/time.h" 3



# 132 "/usr/include/sys/types.h" 2 3


# 143 "/usr/include/sys/types.h" 3



# 1 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 1 3






 


# 19 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3



 


 





 


# 61 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 





 


















 





 

 

# 131 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 


# 188 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3





 




 

# 271 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


# 283 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 

# 317 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3




 





















# 146 "/usr/include/sys/types.h" 2 3



 
typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;


 

# 180 "/usr/include/sys/types.h" 3


 







typedef int int8_t __attribute__ ((__mode__ (  __QI__ ))) ;
typedef int int16_t __attribute__ ((__mode__ (  __HI__ ))) ;
typedef int int32_t __attribute__ ((__mode__ (  __SI__ ))) ;
typedef int int64_t __attribute__ ((__mode__ (  __DI__ ))) ;


typedef unsigned int u_int8_t __attribute__ ((__mode__ (  __QI__ ))) ;
typedef unsigned int u_int16_t __attribute__ ((__mode__ (  __HI__ ))) ;
typedef unsigned int u_int32_t __attribute__ ((__mode__ (  __SI__ ))) ;
typedef unsigned int u_int64_t __attribute__ ((__mode__ (  __DI__ ))) ;

typedef int register_t __attribute__ ((__mode__ (__word__)));


 






 
# 1 "/usr/include/endian.h" 1 3
 






















 











 
# 1 "/usr/include/bits/endian.h" 1 3
 






# 37 "/usr/include/endian.h" 2 3


 



















# 212 "/usr/include/sys/types.h" 2 3


 
# 1 "/usr/include/sys/select.h" 1 3
 


















 






 


 
# 1 "/usr/include/bits/select.h" 1 3
 

























# 36 "/usr/include/bits/select.h" 3












# 56 "/usr/include/bits/select.h" 3

# 72 "/usr/include/bits/select.h" 3

# 31 "/usr/include/sys/select.h" 2 3


 
# 1 "/usr/include/bits/sigset.h" 1 3
 





















typedef int __sig_atomic_t;

 


typedef struct
  {
    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int))) ];
  } __sigset_t;




 





# 125 "/usr/include/bits/sigset.h" 3

# 34 "/usr/include/sys/select.h" 2 3




typedef __sigset_t sigset_t;


 


# 1 "/usr/include/time.h" 1 3
 

















 














# 51 "/usr/include/time.h" 3


# 61 "/usr/include/time.h" 3



# 72 "/usr/include/time.h" 3



# 84 "/usr/include/time.h" 3



# 96 "/usr/include/time.h" 3








 

struct timespec
  {
    __time_t tv_sec;		 
    long int tv_nsec;		 
  };





# 364 "/usr/include/time.h" 3



# 44 "/usr/include/sys/select.h" 2 3


# 1 "/usr/include/bits/time.h" 1 3
 


















 



# 57 "/usr/include/bits/time.h" 3








 

struct timeval
  {
    __time_t tv_sec;		 
    __suseconds_t tv_usec;	 
  };


# 46 "/usr/include/sys/select.h" 2 3



typedef __suseconds_t suseconds_t;




 
typedef long int __fd_mask;

 




 
typedef struct
  {
     





    __fd_mask __fds_bits[1024  / (8 * sizeof (__fd_mask)) ];


  } fd_set;

 



 
typedef __fd_mask fd_mask;

 




 






 

 




extern int select (int __nfds, fd_set *__restrict __readfds,
		   fd_set *__restrict __writefds,
		   fd_set *__restrict __exceptfds,
		   struct timeval *__restrict __timeout)  ;

# 116 "/usr/include/sys/select.h" 3


 


# 215 "/usr/include/sys/types.h" 2 3


 
# 1 "/usr/include/sys/sysmacros.h" 1 3
 





















 








# 47 "/usr/include/sys/sysmacros.h" 3



# 218 "/usr/include/sys/types.h" 2 3









 


typedef __blkcnt_t blkcnt_t;	  



typedef __fsblkcnt_t fsblkcnt_t;  



typedef __fsfilcnt_t fsfilcnt_t;  


# 254 "/usr/include/sys/types.h" 3








 


# 39 "comm.c" 2


# 1 "/usr/include/sys/time.h" 1 3
 
























# 1 "/usr/include/time.h" 1 3
 

















 














# 51 "/usr/include/time.h" 3


# 61 "/usr/include/time.h" 3



# 72 "/usr/include/time.h" 3



# 84 "/usr/include/time.h" 3



# 96 "/usr/include/time.h" 3




# 112 "/usr/include/time.h" 3




# 364 "/usr/include/time.h" 3



# 26 "/usr/include/sys/time.h" 2 3


# 1 "/usr/include/bits/time.h" 1 3
 


















 



# 57 "/usr/include/bits/time.h" 3




# 72 "/usr/include/bits/time.h" 3


# 28 "/usr/include/sys/time.h" 2 3










 

# 50 "/usr/include/sys/time.h" 3




 

struct timezone
  {
    int tz_minuteswest;		 
    int tz_dsttime;		 
  };

typedef struct timezone *__restrict __timezone_ptr_t;




 




extern int gettimeofday (struct timeval *__restrict __tv,
			 __timezone_ptr_t __tz)  ;


 

extern int settimeofday (__const struct timeval *__tv,
			 __const struct timezone *__tz)  ;

 



extern int adjtime (__const struct timeval *__delta,
		    struct timeval *__olddelta)  ;



 
enum __itimer_which
  {
     
    ITIMER_REAL = 0,

     
    ITIMER_VIRTUAL = 1,

     

    ITIMER_PROF = 2

  };

 

struct itimerval
  {
     
    struct timeval it_interval;
     
    struct timeval it_value;
  };






typedef int __itimer_which_t;


 

extern int getitimer (__itimer_which_t __which,
		      struct itimerval *__value)  ;

 


extern int setitimer (__itimer_which_t __which,
		      __const struct itimerval *__restrict __new,
		      struct itimerval *__restrict __old)  ;

 

extern int utimes (__const char *__file, __const struct timeval __tvp[2])
      ;



 








# 160 "/usr/include/sys/time.h" 3

# 169 "/usr/include/sys/time.h" 3


 


# 41 "comm.c" 2








# 1 "/usr/include/ctype.h" 1 3
 

















 









 


 














enum
{
  _ISupper = (( 0 ) < 8 ? ((1 << ( 0 )) << 8) : ((1 << ( 0 )) >> 8)) ,	 
  _ISlower = (( 1 ) < 8 ? ((1 << ( 1 )) << 8) : ((1 << ( 1 )) >> 8)) ,	 
  _ISalpha = (( 2 ) < 8 ? ((1 << ( 2 )) << 8) : ((1 << ( 2 )) >> 8)) ,	 
  _ISdigit = (( 3 ) < 8 ? ((1 << ( 3 )) << 8) : ((1 << ( 3 )) >> 8)) ,	 
  _ISxdigit = (( 4 ) < 8 ? ((1 << ( 4 )) << 8) : ((1 << ( 4 )) >> 8)) ,	 
  _ISspace = (( 5 ) < 8 ? ((1 << ( 5 )) << 8) : ((1 << ( 5 )) >> 8)) ,	 
  _ISprint = (( 6 ) < 8 ? ((1 << ( 6 )) << 8) : ((1 << ( 6 )) >> 8)) ,	 
  _ISgraph = (( 7 ) < 8 ? ((1 << ( 7 )) << 8) : ((1 << ( 7 )) >> 8)) ,	 
  _ISblank = (( 8 ) < 8 ? ((1 << ( 8 )) << 8) : ((1 << ( 8 )) >> 8)) ,	 
  _IScntrl = (( 9 ) < 8 ? ((1 << ( 9 )) << 8) : ((1 << ( 9 )) >> 8)) ,	 
  _ISpunct = (( 10 ) < 8 ? ((1 << ( 10 )) << 8) : ((1 << ( 10 )) >> 8)) ,	 
  _ISalnum = (( 11 ) < 8 ? ((1 << ( 11 )) << 8) : ((1 << ( 11 )) >> 8)) 	 
};


 










extern __const unsigned short int *__ctype_b;	 
extern __const __int32_t *__ctype_tolower;  
extern __const __int32_t *__ctype_toupper;  









 



extern int  isalnum  (int)   ;
extern int  isalpha  (int)   ;
extern int  iscntrl  (int)   ;
extern int  isdigit  (int)   ;
extern int  islower  (int)   ;
extern int  isgraph  (int)   ;
extern int  isprint  (int)   ;
extern int  ispunct  (int)   ;
extern int  isspace  (int)   ;
extern int  isupper  (int)   ;
extern int  isxdigit  (int)   ;






 
extern int tolower (int __c)  ;

 
extern int toupper (int __c)  ;




 

extern int isascii (int __c)  ;

 

extern int toascii (int __c)  ;

 

extern int  _toupper  (int)   ;
extern int  _tolower  (int)   ;


 

# 148 "/usr/include/ctype.h" 3



















extern __inline int
tolower (int __c)  
{
  return __c >= -128 && __c < 256 ? __ctype_tolower[__c] : __c;
}

extern __inline int
toupper (int __c)  
{
  return __c >= -128 && __c < 256 ? __ctype_toupper[__c] : __c;
}


















# 274 "/usr/include/ctype.h" 3


 


# 49 "comm.c" 2

# 1 "/usr/include/errno.h" 1 3
 

















 





 






 

 

# 1 "/usr/include/bits/errno.h" 1 3
 























# 1 "/usr/include/linux/errno.h" 1 3



# 1 "/usr/include/asm/errno.h" 1 3




































































































































# 4 "/usr/include/linux/errno.h" 2 3


# 24 "/usr/include/linux/errno.h" 3



# 25 "/usr/include/bits/errno.h" 2 3


 


 




 
extern int errno;

 
extern int *__errno_location (void)   __attribute__ ((__const__));







 













# 36 "/usr/include/errno.h" 2 3





 

















 



 










# 50 "comm.c" 2

# 1 "/usr/include/stdio.h" 1 3
 


















 









 



# 1 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 1 3






 


# 19 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3



 


 





 


# 61 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 





 


















 





 

 

# 131 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 


# 188 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3





 




 

# 271 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


# 283 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 

# 317 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3




 





















# 34 "/usr/include/stdio.h" 2 3










 
typedef struct _IO_FILE FILE;








 
typedef struct _IO_FILE __FILE;









# 1 "/usr/include/libio.h" 1 3
 






























# 1 "/usr/include/_G_config.h" 1 3
 





 






# 1 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 1 3






 


# 19 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3



 


 





 


# 61 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 





 


















 





 

 

# 131 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 


# 188 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3





 




 





























 


























typedef long int wchar_t;
























typedef unsigned int  wint_t;




 

 

# 317 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3




 





















# 14 "/usr/include/_G_config.h" 2 3










# 1 "/usr/include/wchar.h" 1 3
 

















 











# 46 "/usr/include/wchar.h" 3


# 1 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 1 3






 


# 19 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3



 


 





 


# 61 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 





 


















 





 

 

# 131 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 

# 190 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3



 




 

# 271 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3














 

 

# 317 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3




 





















# 48 "/usr/include/wchar.h" 2 3


# 1 "/usr/include/bits/wchar.h" 1 3
 

























# 50 "/usr/include/wchar.h" 2 3


 













 
typedef struct
{
  int __count;
  union
  {
    wint_t __wch;
    char __wchb[4];
  } __value;		 
} __mbstate_t;




 

# 682 "/usr/include/wchar.h" 3



# 24 "/usr/include/_G_config.h" 2 3


typedef struct
{
  __off_t __pos;
  __mbstate_t __state;
} _G_fpos_t;
typedef struct
{
  __off64_t __pos;
  __mbstate_t __state;
} _G_fpos64_t;








# 1 "/usr/include/gconv.h" 1 3
 

















 








# 1 "/usr/include/wchar.h" 1 3
 

















 











# 46 "/usr/include/wchar.h" 3


# 1 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 1 3






 


# 19 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3



 


 





 


# 61 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 





 


















 





 

 

# 131 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 

# 190 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3



 




 

# 271 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3














 

 

# 317 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3




 





















# 48 "/usr/include/wchar.h" 2 3




 











# 76 "/usr/include/wchar.h" 3




 

# 682 "/usr/include/wchar.h" 3



# 28 "/usr/include/gconv.h" 2 3



# 1 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 1 3






 


# 19 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3



 


 





 


# 61 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 





 


















 





 

 

# 131 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 


# 188 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3





 




 


# 269 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3




# 283 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 

# 317 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3




 





















# 31 "/usr/include/gconv.h" 2 3


 


 
enum
{
  __GCONV_OK = 0,
  __GCONV_NOCONV,
  __GCONV_NODB,
  __GCONV_NOMEM,

  __GCONV_EMPTY_INPUT,
  __GCONV_FULL_OUTPUT,
  __GCONV_ILLEGAL_INPUT,
  __GCONV_INCOMPLETE_INPUT,

  __GCONV_ILLEGAL_DESCRIPTOR,
  __GCONV_INTERNAL_ERROR
};


 
enum
{
  __GCONV_IS_LAST = 0x0001,
  __GCONV_IGNORE_ERRORS = 0x0002
};


 
struct __gconv_step;
struct __gconv_step_data;
struct __gconv_loaded_object;
struct __gconv_trans_data;


 
typedef int (*__gconv_fct) (struct __gconv_step *, struct __gconv_step_data *,
			    __const unsigned char **, __const unsigned char *,
			    unsigned char **, size_t *, int, int);

 
typedef int (*__gconv_init_fct) (struct __gconv_step *);
typedef void (*__gconv_end_fct) (struct __gconv_step *);


 
typedef int (*__gconv_trans_fct) (struct __gconv_step *,
				  struct __gconv_step_data *, void *,
				  __const unsigned char *,
				  __const unsigned char **,
				  __const unsigned char *, unsigned char **,
				  size_t *);

 
typedef int (*__gconv_trans_context_fct) (void *, __const unsigned char *,
					  __const unsigned char *,
					  unsigned char *, unsigned char *);

 
typedef int (*__gconv_trans_query_fct) (__const char *, __const char ***,
					size_t *);

 
typedef int (*__gconv_trans_init_fct) (void **, const char *);
typedef void (*__gconv_trans_end_fct) (void *);

struct __gconv_trans_data
{
   
  __gconv_trans_fct __trans_fct;
  __gconv_trans_context_fct __trans_context_fct;
  __gconv_trans_end_fct __trans_end_fct;
  void *__data;
  struct __gconv_trans_data *__next;
};


 
struct __gconv_step
{
  struct __gconv_loaded_object *__shlib_handle;
  __const char *__modname;

  int __counter;

  char *__from_name;
  char *__to_name;

  __gconv_fct __fct;
  __gconv_init_fct __init_fct;
  __gconv_end_fct __end_fct;

   

  int __min_needed_from;
  int __max_needed_from;
  int __min_needed_to;
  int __max_needed_to;

   
  int __stateful;

  void *__data;		 
};

 

struct __gconv_step_data
{
  unsigned char *__outbuf;     
  unsigned char *__outbufend;  


   
  int __flags;

   

  int __invocation_counter;

   

  int __internal_use;

  __mbstate_t *__statep;
  __mbstate_t __state;	 


   
  struct __gconv_trans_data *__trans;
};


 
typedef struct __gconv_info
{
  size_t __nsteps;
  struct __gconv_step *__steps;
  __extension__ struct __gconv_step_data __data [0] ;
} *__gconv_t;


# 44 "/usr/include/_G_config.h" 2 3

typedef union
{
  struct __gconv_info __cd;
  struct
  {
    struct __gconv_info __cd;
    struct __gconv_step_data __data;
  } __combined;
} _G_iconv_t;

typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));




 


















 




 














# 32 "/usr/include/libio.h" 2 3

 

















 








# 72 "/usr/include/libio.h" 3


 

















# 103 "/usr/include/libio.h" 3











 

























 



















struct _IO_jump_t;  struct _IO_FILE;

 







typedef void _IO_lock_t;



 

struct _IO_marker {
  struct _IO_marker *_next;
  struct _IO_FILE *_sbuf;
   

   
  int _pos;
# 192 "/usr/include/libio.h" 3

};

 
enum __codecvt_result
{
  __codecvt_ok,
  __codecvt_partial,
  __codecvt_error,
  __codecvt_noconv
};

# 259 "/usr/include/libio.h" 3


struct _IO_FILE {
  int _flags;		 


   
   
  char* _IO_read_ptr;	 
  char* _IO_read_end;	 
  char* _IO_read_base;	 
  char* _IO_write_base;	 
  char* _IO_write_ptr;	 
  char* _IO_write_end;	 
  char* _IO_buf_base;	 
  char* _IO_buf_end;	 
   
  char *_IO_save_base;  
  char *_IO_backup_base;   
  char *_IO_save_end;  

  struct _IO_marker *_markers;

  struct _IO_FILE *_chain;

  int _fileno;
  int _blksize;
  __off_t   _old_offset;  


   
  unsigned short _cur_column;
  signed char _vtable_offset;
  char _shortbuf[1];

   

  _IO_lock_t *_lock;








  __off64_t   _offset;





  void *__pad1;
  void *__pad2;

  int _mode;
   
  char _unused2[15 * sizeof (int) - 2 * sizeof (void *)];

};


typedef struct _IO_FILE _IO_FILE;


struct _IO_FILE_plus;

extern struct _IO_FILE_plus _IO_2_1_stdin_;
extern struct _IO_FILE_plus _IO_2_1_stdout_;
extern struct _IO_FILE_plus _IO_2_1_stderr_;











 

 

typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);

 





typedef __ssize_t __io_write_fn (void *__cookie, __const char *__buf,
				 size_t __n);

 





typedef int __io_seek_fn (void *__cookie, __off64_t   *__pos, int __w);

 
typedef int __io_close_fn (void *__cookie);


# 389 "/usr/include/libio.h" 3







extern int __underflow (_IO_FILE *)  ;
extern int __uflow (_IO_FILE *)  ;
extern int __overflow (_IO_FILE *, int)  ;
extern wint_t   __wunderflow (_IO_FILE *)  ;
extern wint_t   __wuflow (_IO_FILE *)  ;
extern wint_t   __woverflow (_IO_FILE *, wint_t  )  ;
























extern int _IO_getc (_IO_FILE *__fp)  ;
extern int _IO_putc (int __c, _IO_FILE *__fp)  ;
extern int _IO_feof (_IO_FILE *__fp)  ;
extern int _IO_ferror (_IO_FILE *__fp)  ;

extern int _IO_peekc_locked (_IO_FILE *__fp)  ;

 



extern void _IO_flockfile (_IO_FILE *)  ;
extern void _IO_funlockfile (_IO_FILE *)  ;
extern int _IO_ftrylockfile (_IO_FILE *)  ;
















extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
			__gnuc_va_list , int *__restrict)  ;
extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
			 __gnuc_va_list )  ;
extern __ssize_t   _IO_padn (_IO_FILE *, int, __ssize_t  )  ;
extern size_t   _IO_sgetn (_IO_FILE *, void *, size_t  )  ;

extern __off64_t   _IO_seekoff (_IO_FILE *, __off64_t  , int, int)  ;
extern __off64_t   _IO_seekpos (_IO_FILE *, __off64_t  , int)  ;

extern void _IO_free_backup_area (_IO_FILE *)  ;

# 511 "/usr/include/libio.h" 3







# 65 "/usr/include/stdio.h" 2 3


# 76 "/usr/include/stdio.h" 3


 

typedef _G_fpos_t fpos_t;







 





 





 






 







 




 








# 1 "/usr/include/bits/stdio_lim.h" 1 3
 








































# 129 "/usr/include/stdio.h" 2 3



 
extern FILE *stdin;		 
extern FILE *stdout;		 
extern FILE *stderr;		 
 




 
extern int remove (__const char *__filename)  ;
 
extern int rename (__const char *__old, __const char *__new)  ;


 

extern FILE *tmpfile (void)  ;










 
extern char *tmpnam (char *__s)  ;


 

extern char *tmpnam_r (char *__s)  ;




 






extern char *tempnam (__const char *__dir, __const char *__pfx)
        ;



 
extern int fclose (FILE *__stream)  ;
 
extern int fflush (FILE *__stream)  ;


 
extern int fflush_unlocked (FILE *__stream)  ;









 
extern FILE *fopen (__const char *__restrict __filename,
		    __const char *__restrict __modes)  ;
 
extern FILE *freopen (__const char *__restrict __filename,
		      __const char *__restrict __modes,
		      FILE *__restrict __stream)  ;
# 220 "/usr/include/stdio.h" 3










 
extern FILE *fdopen (int __fd, __const char *__modes)  ;


# 249 "/usr/include/stdio.h" 3



 

extern void setbuf (FILE *__restrict __stream, char *__restrict __buf)  ;
 


extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
		    int __modes, size_t __n)  ;


 

extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
		       size_t __size)  ;

 
extern void setlinebuf (FILE *__stream)  ;



 
extern int fprintf (FILE *__restrict __stream,
		    __const char *__restrict __format, ...)  ;
 
extern int printf (__const char *__restrict __format, ...)  ;
 
extern int sprintf (char *__restrict __s,
		    __const char *__restrict __format, ...)  ;

 
extern int vfprintf (FILE *__restrict __s, __const char *__restrict __format,
		     __gnuc_va_list  __arg)  ;
 
extern int vprintf (__const char *__restrict __format, __gnuc_va_list  __arg)
      ;
 
extern int vsprintf (char *__restrict __s, __const char *__restrict __format,
		     __gnuc_va_list  __arg)  ;


 
extern int snprintf (char *__restrict __s, size_t __maxlen,
		     __const char *__restrict __format, ...)
       __attribute__ ((__format__ (__printf__, 3, 4)));

extern int vsnprintf (char *__restrict __s, size_t __maxlen,
		      __const char *__restrict __format, __gnuc_va_list  __arg)
       __attribute__ ((__format__ (__printf__, 3, 0)));


# 321 "/usr/include/stdio.h" 3



 
extern int fscanf (FILE *__restrict __stream,
		   __const char *__restrict __format, ...)  ;
 
extern int scanf (__const char *__restrict __format, ...)  ;
 
extern int sscanf (__const char *__restrict __s,
		   __const char *__restrict __format, ...)  ;

# 347 "/usr/include/stdio.h" 3



 
extern int fgetc (FILE *__stream)  ;
extern int getc (FILE *__stream)  ;

 
extern int getchar (void)  ;

 




 
extern int getc_unlocked (FILE *__stream)  ;
extern int getchar_unlocked (void)  ;



 
extern int fgetc_unlocked (FILE *__stream)  ;



 
extern int fputc (int __c, FILE *__stream)  ;
extern int putc (int __c, FILE *__stream)  ;

 
extern int putchar (int __c)  ;

 




 
extern int fputc_unlocked (int __c, FILE *__stream)  ;



 
extern int putc_unlocked (int __c, FILE *__stream)  ;
extern int putchar_unlocked (int __c)  ;




 
extern int getw (FILE *__stream)  ;

 
extern int putw (int __w, FILE *__stream)  ;



 
extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
      ;







 

extern char *gets (char *__s)  ;


# 437 "/usr/include/stdio.h" 3



 
extern int fputs (__const char *__restrict __s, FILE *__restrict __stream)
      ;







 
extern int puts (__const char *__s)  ;


 
extern int ungetc (int __c, FILE *__stream)  ;


 
extern size_t fread (void *__restrict __ptr, size_t __size,
		     size_t __n, FILE *__restrict __stream)  ;
 
extern size_t fwrite (__const void *__restrict __ptr, size_t __size,
		      size_t __n, FILE *__restrict __s)  ;


 
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
			      size_t __n, FILE *__restrict __stream)  ;
extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size,
			       size_t __n, FILE *__restrict __stream)  ;



 
extern int fseek (FILE *__stream, long int __off, int __whence)  ;
 
extern long int ftell (FILE *__stream)  ;
 
extern void rewind (FILE *__stream)  ;

 












 
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos)
      ;
 
extern int fsetpos (FILE *__stream, __const fpos_t *__pos)  ;
# 520 "/usr/include/stdio.h" 3










 
extern void clearerr (FILE *__stream)  ;
 
extern int feof (FILE *__stream)  ;
 
extern int ferror (FILE *__stream)  ;


 
extern void clearerr_unlocked (FILE *__stream)  ;
extern int feof_unlocked (FILE *__stream)  ;
extern int ferror_unlocked (FILE *__stream)  ;



 
extern void perror (__const char *__s)  ;

 


extern int sys_nerr;
extern __const char *__const sys_errlist[];








 
extern int fileno (FILE *__stream)  ;



 
extern int fileno_unlocked (FILE *__stream)  ;





 
extern FILE *popen (__const char *__command, __const char *__modes)  ;

 
extern int pclose (FILE *__stream)  ;




 
extern char *ctermid (char *__s)  ;









# 602 "/usr/include/stdio.h" 3




 

 
extern void flockfile (FILE *__stream)  ;

 

extern int ftrylockfile (FILE *__stream)  ;

 
extern void funlockfile (FILE *__stream)  ;










 


# 1 "/usr/include/bits/stdio.h" 1 3
 






























 
extern __inline  int
vprintf (__const char *__restrict __fmt, __gnuc_va_list  __arg)  
{
  return vfprintf (stdout , __fmt, __arg);
}

 
extern __inline  int
getchar (void)  
{
  return _IO_getc (stdin );
}



 
extern __inline  int
getc_unlocked (FILE *__fp)  
{
  return (( __fp )->_IO_read_ptr >= ( __fp )->_IO_read_end ? __uflow ( __fp ) : *(unsigned char *) ( __fp )->_IO_read_ptr++) ;
}

 
extern __inline  int
getchar_unlocked (void)  
{
  return (( stdin  )->_IO_read_ptr >= ( stdin  )->_IO_read_end ? __uflow ( stdin  ) : *(unsigned char *) ( stdin  )->_IO_read_ptr++) ;
}



 
extern __inline  int
putchar (int __c)  
{
  return _IO_putc (__c, stdout );
}



 
extern __inline  int
fputc_unlocked (int __c, FILE *__stream)  
{
  return (((  __stream )->_IO_write_ptr >= (  __stream )->_IO_write_end) ? __overflow (  __stream , (unsigned char) ( __c )) : (unsigned char) (*(  __stream )->_IO_write_ptr++ = ( __c ))) ;
}




 
extern __inline  int
putc_unlocked (int __c, FILE *__stream)  
{
  return (((  __stream )->_IO_write_ptr >= (  __stream )->_IO_write_end) ? __overflow (  __stream , (unsigned char) ( __c )) : (unsigned char) (*(  __stream )->_IO_write_ptr++ = ( __c ))) ;
}

 
extern __inline  int
putchar_unlocked (int __c)  
{
  return (((  stdout  )->_IO_write_ptr >= (  stdout  )->_IO_write_end) ? __overflow (  stdout  , (unsigned char) ( __c )) : (unsigned char) (*(  stdout  )->_IO_write_ptr++ = ( __c ))) ;
}














 
extern __inline  int
feof_unlocked (FILE *__stream)  
{
  return ((( __stream )->_flags & 0x10 ) != 0) ;
}

 
extern __inline  int
ferror_unlocked (FILE *__stream)  
{
  return ((( __stream )->_flags & 0x20 ) != 0) ;
}






 

# 150 "/usr/include/bits/stdio.h" 3


# 166 "/usr/include/bits/stdio.h" 3


 

# 630 "/usr/include/stdio.h" 2 3



 




# 51 "comm.c" 2

# 1 "/usr/include/stdlib.h" 1 3
 

















 







 





# 1 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 1 3






 


# 19 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3



 


 





 


# 61 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 





 


















 





 

 

# 131 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 


# 188 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3





 




 


# 269 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3




# 283 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 

# 317 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3




 





















# 33 "/usr/include/stdlib.h" 2 3


 




# 91 "/usr/include/stdlib.h" 3


 
typedef struct
  {
    int quot;			 
    int rem;			 
  } div_t;

 

typedef struct
  {
    long int quot;		 
    long int rem;		 
  } ldiv_t;



# 118 "/usr/include/stdlib.h" 3



 



 





 

extern size_t __ctype_get_mb_cur_max (void)  ;


 
extern double atof (__const char *__nptr)    ;
 
extern int atoi (__const char *__nptr)    ;
 
extern long int atol (__const char *__nptr)    ;


 
__extension__ extern long long int atoll (__const char *__nptr)
        ;


 
extern double strtod (__const char *__restrict __nptr,
		      char **__restrict __endptr)  ;










 
extern long int strtol (__const char *__restrict __nptr,
			char **__restrict __endptr, int __base)  ;
 
extern unsigned long int strtoul (__const char *__restrict __nptr,
				  char **__restrict __endptr, int __base)
      ;


 
__extension__
extern long long int strtoq (__const char *__restrict __nptr,
			     char **__restrict __endptr, int __base)  ;
 
__extension__
extern unsigned long long int strtouq (__const char *__restrict __nptr,
				       char **__restrict __endptr, int __base)
      ;



 

 
__extension__
extern long long int strtoll (__const char *__restrict __nptr,
			      char **__restrict __endptr, int __base)  ;
 
__extension__
extern unsigned long long int strtoull (__const char *__restrict __nptr,
					char **__restrict __endptr, int __base)
      ;



# 244 "/usr/include/stdlib.h" 3



 


extern double __strtod_internal (__const char *__restrict __nptr,
				 char **__restrict __endptr, int __group)
      ;
extern float __strtof_internal (__const char *__restrict __nptr,
				char **__restrict __endptr, int __group)
      ;
extern long double __strtold_internal (__const char *__restrict __nptr,
				       char **__restrict __endptr,
				       int __group)  ;

extern long int __strtol_internal (__const char *__restrict __nptr,
				   char **__restrict __endptr,
				   int __base, int __group)  ;



extern unsigned long int __strtoul_internal (__const char *__restrict __nptr,
					     char **__restrict __endptr,
					     int __base, int __group)  ;




__extension__
extern long long int __strtoll_internal (__const char *__restrict __nptr,
					 char **__restrict __endptr,
					 int __base, int __group)  ;



__extension__
extern unsigned long long int __strtoull_internal (__const char *
						   __restrict __nptr,
						   char **__restrict __endptr,
						   int __base, int __group)
      ;





 

extern __inline double
strtod (__const char *__restrict __nptr, char **__restrict __endptr)  
{
  return __strtod_internal (__nptr, __endptr, 0);
}
extern __inline long int
strtol (__const char *__restrict __nptr, char **__restrict __endptr,
	int __base)  
{
  return __strtol_internal (__nptr, __endptr, __base, 0);
}
extern __inline unsigned long int
strtoul (__const char *__restrict __nptr, char **__restrict __endptr,
	 int __base)  
{
  return __strtoul_internal (__nptr, __endptr, __base, 0);
}

# 322 "/usr/include/stdlib.h" 3



__extension__ extern __inline long long int
strtoq (__const char *__restrict __nptr, char **__restrict __endptr,
	int __base)  
{
  return __strtoll_internal (__nptr, __endptr, __base, 0);
}
__extension__ extern __inline unsigned long long int
strtouq (__const char *__restrict __nptr, char **__restrict __endptr,
	 int __base)  
{
  return __strtoull_internal (__nptr, __endptr, __base, 0);
}



__extension__ extern __inline long long int
strtoll (__const char *__restrict __nptr, char **__restrict __endptr,
	 int __base)  
{
  return __strtoll_internal (__nptr, __endptr, __base, 0);
}
__extension__ extern __inline unsigned long long int
strtoull (__const char * __restrict __nptr, char **__restrict __endptr,
	  int __base)  
{
  return __strtoull_internal (__nptr, __endptr, __base, 0);
}


extern __inline double
atof (__const char *__nptr)  
{
  return strtod (__nptr, (char **) ((void *)0) );
}
extern __inline int
atoi (__const char *__nptr)  
{
  return (int) strtol (__nptr, (char **) ((void *)0) , 10);
}
extern __inline long int
atol (__const char *__nptr)  
{
  return strtol (__nptr, (char **) ((void *)0) , 10);
}


__extension__ extern __inline long long int
atoll (__const char *__nptr)  
{
  return strtoll (__nptr, (char **) ((void *)0) , 10);
}





 


extern char *l64a (long int __n)  ;

 
extern long int a64l (__const char *__s)    ;




 



 
extern long int random (void)  ;

 
extern void srandom (unsigned int __seed)  ;

 



extern char *initstate (unsigned int __seed, char *__statebuf,
			size_t __statelen)  ;

 

extern char *setstate (char *__statebuf)  ;



 



struct random_data
  {
    int32_t *fptr;		 
    int32_t *rptr;		 
    int32_t *state;		 
    int rand_type;		 
    int rand_deg;		 
    int rand_sep;		 
    int32_t *end_ptr;		 
  };

extern int random_r (struct random_data *__restrict __buf,
		     int32_t *__restrict __result)  ;

extern int srandom_r (unsigned int __seed, struct random_data *__buf)  ;

extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
			size_t __statelen,
			struct random_data *__restrict __buf)  ;

extern int setstate_r (char *__restrict __statebuf,
		       struct random_data *__restrict __buf)  ;




 
extern int rand (void)  ;
 
extern void srand (unsigned int __seed)  ;


 
extern int rand_r (unsigned int *__seed)  ;




 

 
extern double drand48 (void)  ;
extern double erand48 (unsigned short int __xsubi[3])  ;

 
extern long int lrand48 (void)  ;
extern long int nrand48 (unsigned short int __xsubi[3])  ;

 
extern long int mrand48 (void)  ;
extern long int jrand48 (unsigned short int __xsubi[3])  ;

 
extern void srand48 (long int __seedval)  ;
extern unsigned short int *seed48 (unsigned short int __seed16v[3])  ;
extern void lcong48 (unsigned short int __param[7])  ;


 


struct drand48_data
  {
    unsigned short int __x[3];	 
    unsigned short int __old_x[3];  
    unsigned short int __c;	 
    unsigned short int __init;	 
    unsigned long long int __a;	 
  };

 
extern int drand48_r (struct drand48_data *__restrict __buffer,
		      double *__restrict __result)  ;
extern int erand48_r (unsigned short int __xsubi[3],
		      struct drand48_data *__restrict __buffer,
		      double *__restrict __result)  ;

 
extern int lrand48_r (struct drand48_data *__restrict __buffer,
		      long int *__restrict __result)  ;
extern int nrand48_r (unsigned short int __xsubi[3],
		      struct drand48_data *__restrict __buffer,
		      long int *__restrict __result)  ;

 
extern int mrand48_r (struct drand48_data *__restrict __buffer,
		      long int *__restrict __result)  ;
extern int jrand48_r (unsigned short int __xsubi[3],
		      struct drand48_data *__restrict __buffer,
		      long int *__restrict __result)  ;

 
extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
      ;

extern int seed48_r (unsigned short int __seed16v[3],
		     struct drand48_data *__buffer)  ;

extern int lcong48_r (unsigned short int __param[7],
		      struct drand48_data *__buffer)  ;







 
extern void *malloc (size_t __size)    ;
 
extern void *calloc (size_t __nmemb, size_t __size)
        ;



 

extern void *realloc (void *__ptr, size_t __size)    ;
 
extern void free (void *__ptr)  ;


 
extern void cfree (void *__ptr)  ;



# 1 "/usr/include/alloca.h" 1 3
 























# 1 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 1 3






 


# 19 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3



 


 





 


# 61 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 





 


















 





 

 

# 131 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 


# 188 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3





 




 

# 271 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


# 283 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 

# 317 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3




 





















# 25 "/usr/include/alloca.h" 2 3


 

 


 
extern void *alloca (size_t __size)  ;





 


# 546 "/usr/include/stdlib.h" 2 3




 
extern void *valloc (size_t __size)    ;








 
extern void abort (void)   __attribute__ ((__noreturn__));


 
extern int atexit (void (*__func) (void))  ;


 

extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
      ;


 


extern void exit (int __status)   __attribute__ ((__noreturn__));








 
extern char *getenv (__const char *__name)  ;

 

extern char *__secure_getenv (__const char *__name)  ;


 
 

extern int putenv (char *__string)  ;



 

extern int setenv (__const char *__name, __const char *__value, int __replace)
      ;

 
extern int unsetenv (__const char *__name)  ;



 


extern int clearenv (void)  ;




 



extern char *mktemp (char *__template)  ;

 





extern int mkstemp (char *__template)  ;













 




extern char *mkdtemp (char *__template)  ;



 
extern int system (__const char *__command)  ;










 





extern char *realpath (__const char *__restrict __name,
		       char *__restrict __resolved)  ;



 


typedef int (*__compar_fn_t) (__const void *, __const void *);






 

extern void *bsearch (__const void *__key, __const void *__base,
		      size_t __nmemb, size_t __size, __compar_fn_t __compar);

 

extern void qsort (void *__base, size_t __nmemb, size_t __size,
		   __compar_fn_t __compar);


 
extern int abs (int __x)   __attribute__ ((__const__));
extern long int labs (long int __x)   __attribute__ ((__const__));






 

 
extern div_t div (int __numer, int __denom)
       __attribute__ ((__const__));
extern ldiv_t ldiv (long int __numer, long int __denom)
       __attribute__ ((__const__));








 


 


extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
		   int *__restrict __sign)  ;

 


extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
		   int *__restrict __sign)  ;

 


extern char *gcvt (double __value, int __ndigit, char *__buf)  ;



 
extern char *qecvt (long double __value, int __ndigit,
		    int *__restrict __decpt, int *__restrict __sign)  ;
extern char *qfcvt (long double __value, int __ndigit,
		    int *__restrict __decpt, int *__restrict __sign)  ;
extern char *qgcvt (long double __value, int __ndigit, char *__buf)  ;


 

extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
		   int *__restrict __sign, char *__restrict __buf,
		   size_t __len)  ;
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
		   int *__restrict __sign, char *__restrict __buf,
		   size_t __len)  ;

extern int qecvt_r (long double __value, int __ndigit,
		    int *__restrict __decpt, int *__restrict __sign,
		    char *__restrict __buf, size_t __len)  ;
extern int qfcvt_r (long double __value, int __ndigit,
		    int *__restrict __decpt, int *__restrict __sign,
		    char *__restrict __buf, size_t __len)  ;




 

extern int mblen (__const char *__s, size_t __n)  ;
 

extern int mbtowc (wchar_t *__restrict __pwc,
		   __const char *__restrict __s, size_t __n)  ;
 

extern int wctomb (char *__s, wchar_t __wchar)  ;


 
extern size_t mbstowcs (wchar_t *__restrict  __pwcs,
			__const char *__restrict __s, size_t __n)  ;
 
extern size_t wcstombs (char *__restrict __s,
			__const wchar_t *__restrict __pwcs, size_t __n)
      ;



 



extern int rpmatch (__const char *__response)  ;



# 811 "/usr/include/stdlib.h" 3









 






# 842 "/usr/include/stdlib.h" 3


# 852 "/usr/include/stdlib.h" 3



 


extern int getloadavg (double __loadavg[], int __nelem)  ;





 


# 52 "comm.c" 2

# 1 "/usr/include/string.h" 1 3
 

















 








 

 


# 1 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 1 3






 


# 19 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3



 


 





 


# 61 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 





 


















 





 

 

# 131 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 


# 188 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3





 




 

# 271 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


# 283 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 

# 317 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3




 





















# 33 "/usr/include/string.h" 2 3



 
extern void *memcpy (void *__restrict __dest,
		     __const void *__restrict __src, size_t __n)  ;
 

extern void *memmove (void *__dest, __const void *__src, size_t __n)
      ;

 



extern void *memccpy (void *__restrict __dest, __const void *__restrict __src,
		      int __c, size_t __n)
      ;



 
extern void *memset (void *__s, int __c, size_t __n)  ;

 
extern int memcmp (__const void *__s1, __const void *__s2, size_t __n)
        ;

 
extern void *memchr (__const void *__s, int __c, size_t __n)
         ;

# 73 "/usr/include/string.h" 3



 
extern char *strcpy (char *__restrict __dest, __const char *__restrict __src)
      ;
 
extern char *strncpy (char *__restrict __dest,
		      __const char *__restrict __src, size_t __n)  ;

 
extern char *strcat (char *__restrict __dest, __const char *__restrict __src)
      ;
 
extern char *strncat (char *__restrict __dest, __const char *__restrict __src,
		      size_t __n)  ;

 
extern int strcmp (__const char *__s1, __const char *__s2)
        ;
 
extern int strncmp (__const char *__s1, __const char *__s2, size_t __n)
        ;

 
extern int strcoll (__const char *__s1, __const char *__s2)
        ;
 
extern size_t strxfrm (char *__restrict __dest,
		       __const char *__restrict __src, size_t __n)  ;

# 116 "/usr/include/string.h" 3



 
extern char *strdup (__const char *__s)    ;


 







# 152 "/usr/include/string.h" 3


 
extern char *strchr (__const char *__s, int __c)    ;
 
extern char *strrchr (__const char *__s, int __c)    ;







 

extern size_t strcspn (__const char *__s, __const char *__reject)
        ;
 

extern size_t strspn (__const char *__s, __const char *__accept)
        ;
 
extern char *strpbrk (__const char *__s, __const char *__accept)
        ;
 
extern char *strstr (__const char *__haystack, __const char *__needle)
        ;







 
extern char *strtok (char *__restrict __s, __const char *__restrict __delim)
      ;

 

extern char *__strtok_r (char *__restrict __s,
			 __const char *__restrict __delim,
			 char **__restrict __save_ptr)  ;

extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim,
		       char **__restrict __save_ptr)  ;


# 214 "/usr/include/string.h" 3



 
extern size_t strlen (__const char *__s)    ;









 
extern char *strerror (int __errnum)  ;

 

extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)  ;


 

extern void __bzero (void *__s, size_t __n)  ;


 
extern void bcopy (__const void *__src, void *__dest, size_t __n)  ;

 
extern void bzero (void *__s, size_t __n)  ;

 
extern int bcmp (__const void *__s1, __const void *__s2, size_t __n)
        ;

 
extern char *index (__const char *__s, int __c)    ;

 
extern char *rindex (__const char *__s, int __c)    ;

 

extern int ffs (int __i)   __attribute__ ((__const__));

 









 
extern int strcasecmp (__const char *__s1, __const char *__s2)
        ;

 
extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n)
        ;


# 289 "/usr/include/string.h" 3



 

extern char *strsep (char **__restrict __stringp,
		     __const char *__restrict __delim)  ;


# 332 "/usr/include/string.h" 3






 

















 
# 1 "/usr/include/bits/string.h" 1 3
 






















 



 

# 904 "/usr/include/bits/string.h" 3

# 357 "/usr/include/string.h" 2 3


 
# 1 "/usr/include/bits/string2.h" 1 3
 

























 























 












# 73 "/usr/include/bits/string2.h" 3

# 88 "/usr/include/bits/string2.h" 3


 





 















# 180 "/usr/include/bits/string2.h" 3







 








 

# 372 "/usr/include/bits/string2.h" 3



 

extern void *__rawmemchr (const void *__s, int __c);







 



















extern __inline  char *__strcpy_small (char *, __uint16_t, __uint16_t,
				      __uint32_t, __uint32_t, size_t);
extern __inline  char *
__strcpy_small (char *__dest,
		__uint16_t __src0_2, __uint16_t __src4_2,
		__uint32_t __src0_4, __uint32_t __src4_4,
		size_t __srclen)
{
  union {
    __uint32_t __ui;
    __uint16_t __usi;
    unsigned char __uc;
  } *__u = (void *) __dest;
  switch ((unsigned int) __srclen)
    {
    case 1:
      __u->__uc = '\0';
      break;
    case 2:
      __u->__usi = __src0_2;
      break;
    case 3:
      __u->__usi = __src0_2;
      __u = __extension__ ((void *) __u + 2);
      __u->__uc = '\0';
      break;
    case 4:
      __u->__ui = __src0_4;
      break;
    case 5:
      __u->__ui = __src0_4;
      __u = __extension__ ((void *) __u + 4);
      __u->__uc = '\0';
      break;
    case 6:
      __u->__ui = __src0_4;
      __u = __extension__ ((void *) __u + 4);
      __u->__usi = __src4_2;
      break;
    case 7:
      __u->__ui = __src0_4;
      __u = __extension__ ((void *) __u + 4);
      __u->__usi = __src4_2;
      __u = __extension__ ((void *) __u + 2);
      __u->__uc = '\0';
      break;
    case 8:
      __u->__ui = __src0_4;
      __u = __extension__ ((void *) __u + 4);
      __u->__ui = __src4_4;
      break;
    }
  return __dest;
}
# 542 "/usr/include/bits/string2.h" 3




 
# 714 "/usr/include/bits/string2.h" 3



 

# 729 "/usr/include/bits/string2.h" 3











 

# 751 "/usr/include/bits/string2.h" 3











 


# 784 "/usr/include/bits/string2.h" 3


# 811 "/usr/include/bits/string2.h" 3


# 833 "/usr/include/bits/string2.h" 3


# 858 "/usr/include/bits/string2.h" 3



 











 




# 891 "/usr/include/bits/string2.h" 3


extern __inline  size_t __strcspn_c1 (__const char *__s, int __reject);
extern __inline  size_t
__strcspn_c1 (__const char *__s, int __reject)
{
  register size_t __result = 0;
  while (__s[__result] != '\0' && __s[__result] != __reject)
    ++__result;
  return __result;
}

extern __inline  size_t __strcspn_c2 (__const char *__s, int __reject1,
				     int __reject2);
extern __inline  size_t
__strcspn_c2 (__const char *__s, int __reject1, int __reject2)
{
  register size_t __result = 0;
  while (__s[__result] != '\0' && __s[__result] != __reject1
	 && __s[__result] != __reject2)
    ++__result;
  return __result;
}

extern __inline  size_t __strcspn_c3 (__const char *__s, int __reject1,
				     int __reject2, int __reject3);
extern __inline  size_t
__strcspn_c3 (__const char *__s, int __reject1, int __reject2,
	      int __reject3)
{
  register size_t __result = 0;
  while (__s[__result] != '\0' && __s[__result] != __reject1
	 && __s[__result] != __reject2 && __s[__result] != __reject3)
    ++__result;
  return __result;
}



 




# 948 "/usr/include/bits/string2.h" 3


extern __inline  size_t __strspn_c1 (__const char *__s, int __accept);
extern __inline  size_t
__strspn_c1 (__const char *__s, int __accept)
{
  register size_t __result = 0;
   
  while (__s[__result] == __accept)
    ++__result;
  return __result;
}

extern __inline  size_t __strspn_c2 (__const char *__s, int __accept1,
				    int __accept2);
extern __inline  size_t
__strspn_c2 (__const char *__s, int __accept1, int __accept2)
{
  register size_t __result = 0;
   
  while (__s[__result] == __accept1 || __s[__result] == __accept2)
    ++__result;
  return __result;
}

extern __inline  size_t __strspn_c3 (__const char *__s, int __accept1,
				    int __accept2, int __accept3);
extern __inline  size_t
__strspn_c3 (__const char *__s, int __accept1, int __accept2, int __accept3)
{
  register size_t __result = 0;
   
  while (__s[__result] == __accept1 || __s[__result] == __accept2
	 || __s[__result] == __accept3)
    ++__result;
  return __result;
}



 



# 1005 "/usr/include/bits/string2.h" 3


extern __inline  char *__strpbrk_c2 (__const char *__s, int __accept1,
				     int __accept2);
extern __inline  char *
__strpbrk_c2 (__const char *__s, int __accept1, int __accept2)
{
   
  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2)
    ++__s;
  return *__s == '\0' ? ((void *)0)  : (char *) (size_t) __s;
}

extern __inline  char *__strpbrk_c3 (__const char *__s, int __accept1,
				     int __accept2, int __accept3);
extern __inline  char *
__strpbrk_c3 (__const char *__s, int __accept1, int __accept2,
	      int __accept3)
{
   
  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2
	 && *__s != __accept3)
    ++__s;
  return *__s == '\0' ? ((void *)0)  : (char *) (size_t) __s;
}



 



# 1045 "/usr/include/bits/string2.h" 3














extern __inline  char *__strtok_r_1c (char *__s, char __sep, char **__nextp);
extern __inline  char *
__strtok_r_1c (char *__s, char __sep, char **__nextp)
{
  char *__result;
  if (__s == ((void *)0) )
    __s = *__nextp;
  while (*__s == __sep)
    ++__s;
  __result = ((void *)0) ;
  if (*__s != '\0')
    {
      __result = __s++;
      while (*__s != '\0')
	if (*__s++ == __sep)
	  {
	    __s[-1] = '\0';
	    break;
	  }
      *__nextp = __s;
    }
  return __result;
}









extern char *__strsep_g (char **__stringp, __const char *__delim);

# 1107 "/usr/include/bits/string2.h" 3


extern __inline  char *__strsep_1c (char **__s, char __reject);
extern __inline  char *
__strsep_1c (char **__s, char __reject)
{
  register char *__retval = *__s;
  if (__retval != ((void *)0)  && (*__s = (__extension__ (__builtin_constant_p (  __reject ) && (  __reject ) == '\0'	? (char *) __rawmemchr ( __retval ,   __reject )	: strchr ( __retval ,   __reject ))) ) != ((void *)0) )
    *(*__s)++ = '\0';
  return __retval;
}

extern __inline  char *__strsep_2c (char **__s, char __reject1, char __reject2);
extern __inline  char *
__strsep_2c (char **__s, char __reject1, char __reject2)
{
  register char *__retval = *__s;
  if (__retval != ((void *)0) )
    {
      register char *__cp = __retval;
      while (1)
	{
	  if (*__cp == '\0')
	    {
	      __cp = ((void *)0) ;
	  break;
	    }
	  if (*__cp == __reject1 || *__cp == __reject2)
	    {
	      *__cp++ = '\0';
	      break;
	    }
	  ++__cp;
	}
      *__s = __cp;
    }
  return __retval;
}

extern __inline  char *__strsep_3c (char **__s, char __reject1, char __reject2,
				   char __reject3);
extern __inline  char *
__strsep_3c (char **__s, char __reject1, char __reject2, char __reject3)
{
  register char *__retval = *__s;
  if (__retval != ((void *)0) )
    {
      register char *__cp = __retval;
      while (1)
	{
	  if (*__cp == '\0')
	    {
	      __cp = ((void *)0) ;
	  break;
	    }
	  if (*__cp == __reject1 || *__cp == __reject2 || *__cp == __reject3)
	    {
	      *__cp++ = '\0';
	      break;
	    }
	  ++__cp;
	}
      *__s = __cp;
    }
  return __retval;
}





 











extern char *__strdup (__const char *__string)    ;

# 1201 "/usr/include/bits/string2.h" 3








extern char *__strndup (__const char *__string, size_t __n)
        ;

# 1229 "/usr/include/bits/string2.h" 3













# 360 "/usr/include/string.h" 2 3




 


# 53 "comm.c" 2

# 1 "/usr/include/time.h" 1 3
 

















 










 




 


# 1 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 1 3






 


# 19 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3



 


 





 


# 61 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 





 


















 





 

 

# 131 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 


# 188 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3





 




 

# 271 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


# 283 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 

# 317 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3




 





















# 38 "/usr/include/time.h" 2 3


 

# 1 "/usr/include/bits/time.h" 1 3
 


















 







 


 





 


extern long int __sysconf (int);




 

 

 


 






# 73 "/usr/include/bits/time.h" 3

# 42 "/usr/include/time.h" 2 3


 













 
typedef __clock_t clock_t;




# 72 "/usr/include/time.h" 3



# 84 "/usr/include/time.h" 3



# 96 "/usr/include/time.h" 3




# 112 "/usr/include/time.h" 3





 
struct tm
{
  int tm_sec;			 
  int tm_min;			 
  int tm_hour;			 
  int tm_mday;			 
  int tm_mon;			 
  int tm_year;			 
  int tm_wday;			 
  int tm_yday;			 
  int tm_isdst;			 


  long int tm_gmtoff;		 
  __const char *tm_zone;	 




};



 
struct itimerspec
  {
    struct timespec it_interval;
    struct timespec it_value;
  };

 
struct sigevent;











 

extern clock_t clock (void)  ;

 
extern time_t time (time_t *__timer)  ;

 
extern double difftime (time_t __time1, time_t __time0)
       __attribute__ ((__const__));

 
extern time_t mktime (struct tm *__tp)  ;


 


extern size_t strftime (char *__restrict __s, size_t __maxsize,
			__const char *__restrict __format,
			__const struct tm *__restrict __tp)  ;










 

extern struct tm *gmtime (__const time_t *__timer)  ;

 

extern struct tm *localtime (__const time_t *__timer)  ;


 

extern struct tm *gmtime_r (__const time_t *__restrict __timer,
			    struct tm *__restrict __tp)  ;

 

extern struct tm *localtime_r (__const time_t *__restrict __timer,
			       struct tm *__restrict __tp)  ;


 

extern char *asctime (__const struct tm *__tp)  ;

 
extern char *ctime (__const time_t *__timer)  ;


 

 

extern char *asctime_r (__const struct tm *__restrict __tp,
			char *__restrict __buf)  ;

 
extern char *ctime_r (__const time_t *__restrict __timer,
		      char *__restrict __buf)  ;



 
extern char *__tzname[2];	 
extern int __daylight;		 
extern long int __timezone;	 



 
extern char *tzname[2];

 

extern void tzset (void)  ;



extern int daylight;
extern long int timezone;



 

extern int stime (__const time_t *__when)  ;



 






 


 
extern time_t timegm (struct tm *__tp)  ;

 
extern time_t timelocal (struct tm *__tp)  ;

 
extern int dysize (int __year)    __attribute__ ((__const__));




 
extern int nanosleep (__const struct timespec *__requested_time,
		      struct timespec *__remaining)  ;


 
extern int clock_getres (clockid_t __clock_id, struct timespec *__res)  ;

 
extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp)  ;

 
extern int clock_settime (clockid_t __clock_id, __const struct timespec *__tp)
      ;

# 305 "/usr/include/time.h" 3



 
extern int timer_create (clockid_t __clock_id,
			 struct sigevent *__restrict __evp,
			 timer_t *__restrict __timerid)  ;

 
extern int timer_delete (timer_t __timerid)  ;

 
extern int timer_settime (timer_t __timerid, int __flags,
			  __const struct itimerspec *__restrict __value,
			  struct itimerspec *__restrict __ovalue)  ;

 
extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
      ;

 
extern int timer_getoverrun (timer_t __timerid)  ;



# 349 "/usr/include/time.h" 3


# 359 "/usr/include/time.h" 3



 




# 54 "comm.c" 2



# 1 "../include/merc.h" 1
 
















 


















 
int unlink();
int system();


 



















typedef short    int			sh_int;
typedef unsigned char			bool;

# 1 "../include/player.h" 1
 
















 






















     




 











 




 








 


 











 


















 







































 







































 

 





























 















 























 



                               
                               
 




 

























































 













 








 













 
 

 
               




































# 65 "../include/merc.h" 2


 


typedef struct  dummy_arg           DUMMY_ARG;
typedef struct	affect_data			AFFECT_DATA;
typedef struct	known_data			KNOWN_DATA;
typedef struct	sphere_data			SPHERE_DATA;
typedef struct	area_data			AREA_DATA;
typedef struct	ban_data			BAN_DATA;
typedef struct  buf_type            BUFFER;
typedef struct	char_data			CHAR_DATA;
typedef struct	descriptor_data		DESCRIPTOR_DATA;
typedef struct	exit_data			EXIT_DATA;
typedef struct	extra_descr_data	EXTRA_DESCR_DATA;
typedef struct	help_data			HELP_DATA;
typedef struct	help_area_data		HELP_AREA;
typedef struct	kill_data			KILL_DATA;
typedef struct	mob_index_data		MOB_INDEX_DATA;
typedef struct	note_data			NOTE_DATA;
typedef struct	obj_data			OBJ_DATA;
typedef struct	obj_index_data		OBJ_INDEX_DATA;
typedef struct	mem_data			MEM_DATA;
typedef struct	pc_data				PC_DATA;
typedef struct	reset_data			RESET_DATA;
typedef struct	room_index_data		ROOM_INDEX_DATA;
typedef struct	shop_data			SHOP_DATA;
typedef struct	time_info_data		TIME_INFO_DATA;
typedef struct	temp_list			TEMP_LIST;
typedef struct  mprog_list			MPROG_LIST;
typedef struct  mprog_code			MPROG_CODE;
typedef struct  mud_settings			MUD_SETTING;


struct mud_settings
{
	int 	mud_setting;
	int	total_player_count;
	int	Char_Count;
	int     Obj_Count;
	long 	objects_created;
	long    objects_recycled;
	long    mobiles_created;
	long	Objects_Recycled;
	long	Objects_Recycled_HEAP;
	long	Mobiles_Recycle;
	long	Mobiles_Recycle_Heap;
	long	Mobiles_New;
	long 	total_mobiles_created;
	long    total_objects_created;
	long	total_players_connected;
	long 	current_players_connected;
	long    players_recycled;
	long	players_logged;
	int 	last_proc_logged;
	int 	build;
};

struct tmp_list
{
	TEMP_LIST *next;
	CHAR_DATA *ch;
};

 
 


typedef struct board_data BOARD_DATA;










                         
                        

						                            
						   

						


 

struct board_data
{
	char *short_name;  
	char *long_name;   
	int read_level;  
	int write_level; 
	char *names;        
	int force_type;  
	int purge_days;  
	NOTE_DATA * note_first;   
	bool changed;  
		
};



 

extern BOARD_DATA boards[18 ];  


 

void strip_note    ( CHAR_DATA *ch, OBJ_DATA *obj)   ;
void finish_note (BOARD_DATA *board, NOTE_DATA * note);  
void free_note   (NOTE_DATA *note);  
void load_boards (void);  
int board_lookup (const char *name);  
bool is_note_to (CHAR_DATA *ch, NOTE_DATA *note);  
void personal_message (const char *sender, const char *to, const char *subject, const int expire_days, const char *text);
void make_note (const char* board_name, const char *sender, const char *to, const char *subject, const int expire_days, const char *text);
void save_notes ();

 
void handle_con_note_to 		(DESCRIPTOR_DATA *d, char * argument);
void handle_con_note_subject 	(DESCRIPTOR_DATA *d, char * argument);
void handle_con_note_expire 	(DESCRIPTOR_DATA *d, char * argument);
void handle_con_note_text 		(DESCRIPTOR_DATA *d, char * argument);
void handle_con_note_finish 	(DESCRIPTOR_DATA *d, char * argument);


 

 


typedef	void DO_FUN	  ( CHAR_DATA *ch, char *argument )   ;
typedef bool SPEC_FUN	  ( CHAR_DATA *ch )   ;
typedef void SPELL_FUN	  ( int sn, int level, CHAR_DATA *ch, void *vo )   ;
typedef void POWER_FUN	  ( CHAR_DATA *ch, CHAR_DATA *victim, char *argument )   ;



 





 



















 
extern		int			world_affects;

extern          DUMMY_ARG         *     dummy_free;
extern          DUMMY_ARG         *     dummy_list;
extern          int                     thread_count;


 











bool 	copyover_start;
 

bool    Player_Load;
bool    Player_Error;

 
int    copyover_time;
bool    copyover_set;

void 	check_object 	  ( char *argument )   ;
void 	check_both 	  ( char *argument )   ;
void 	check_mobile 	  ( char *argument )   ;

int 	get_object_count 	  ( char *argument )   ;
int 	get_mobile_count 	  ( char *argument )   ;
int 	get_player_count 	  ( char *argument )   ;

 




void clear_stats      (CHAR_DATA *ch)   ;
void room_is_total_darkness   (ROOM_INDEX_DATA *pRoomIndex)   ;
void improve_wpn      (CHAR_DATA *ch,int dtype, bool right_hand)   ;
void improve_stance   (CHAR_DATA *ch)   ;
void skillstance      (CHAR_DATA *ch, CHAR_DATA *victim)   ;
void show_spell       (CHAR_DATA *ch, int dtype)   ;
void fightaction      (CHAR_DATA *ch, CHAR_DATA *victim, int actype , 		int dtype, int wpntype)   ; 

void crack_head       (CHAR_DATA *ch, OBJ_DATA *obj, char *argument)   ;
void critical_hit     (CHAR_DATA *ch, CHAR_DATA *victim, int dt, int dam)   ;
void take_item        (CHAR_DATA *ch, OBJ_DATA *obj)   ;
void raw_kill         (CHAR_DATA *victim)   ;
void trip             (CHAR_DATA *ch, CHAR_DATA *victim)   ;
void disarm           (CHAR_DATA *ch, CHAR_DATA *victim)   ;
void make_corpse      (CHAR_DATA *ch)   ;
void one_hit          (CHAR_DATA *ch, CHAR_DATA *victim, int dt, 		int handtype)   ;

void make_part        (CHAR_DATA *ch, char *argument)   ;

 









void behead                   (CHAR_DATA *victim)   ;
void paradox                  (CHAR_DATA *ch)   ;

 






















 







































 












 



struct clan_table_type
{
	char * clan_name;
	char * clan_leader;
	char * clan_powers_1;
	char * clan_powers_2;
	char * clan_powers_3;
	int    clan_kills [11 ];
	int    lvnum;        
	int    uvnum;        
	int    clan_recall;  
};


struct artifact_type
{
	char * player_name;
	int    object_vnum;
};


 










struct	ban_data
{
	BAN_DATA *	next;
	bool        valid;
	sh_int      ban_flags;
	sh_int      level;
	char *	name;
	char *  reason;
};

struct buf_type
{
	BUFFER *    next;
	bool        valid;
	sh_int      state;   
	sh_int      size;    
	char *      string;  
};

 

BAN_DATA       *new_ban   (void)   ;
void    free_ban   (BAN_DATA *ban)   ;



 

typedef struct	weather_data		WEATHER_DATA;


 



 






 
 









 







 







 



















 













struct	time_info_data
{
	int		hour;
	int		half_hour;
	int		day;
	int		month;
	int		year;
};

struct	weather_data
{
	int		mmhg;
	int		change;
	int		sky;
	int		sunlight;
	sh_int     moon;
	sh_int  moon_count;
};



 






















 







 


struct dummy_arg {
  DUMMY_ARG        *next;
  DESCRIPTOR_DATA  *d;
  char             *buf;
  sh_int           status;
};



 


struct	descriptor_data
{
	GSList *	snoop_by;
	CHAR_DATA *	character;
	CHAR_DATA *	original;
	GString		*host;
	sh_int		descriptor;
    sh_int              lookup_status;
	sh_int		connected;
	bool            valid;
	bool		fcommand;
	char		inbuf	[4 * 160 ];
	char		incomm	[160 ];
	char		inlast	[160 ];
	int		repeat;
	GString		*outbuf;
	int 		telnet_option[255 ];	
	 
	 
	void *		pEdit;  
	char **		pString;  
	int		editor;  
	GString		*showstr_head;
	char * 		showstr_point;
    	int         s_state;

    	enum 
	{
		TOP_LEVEL,
		SEEN_IAC,
		SEEN_DO,
		SEEN_DONT,
		SEEN_WILL,
		SEEN_WONT,
		SEEN_SE,
		SUBNEGOT,
		SEEN_SB
	} telnet_state;


};

struct wiznet_type
{
    char *	name;
    long 	flag;
    int		level;
};

 


struct	str_app_type
{
	sh_int	tohit;
	sh_int	todam;
	sh_int	carry;
	sh_int	wield;
};

struct	int_app_type
{
	sh_int	learn;
};

struct	wis_app_type
{
	sh_int	practice;
};

struct	dex_app_type
{
	sh_int	defensive;
};

struct	con_app_type
{
	sh_int	hitp;
	sh_int	shock;
};



 











 


struct	help_data
{
	HELP_DATA *	next;
	sh_int	level;
	gchar *	keyword;
	gchar *	text;
};



struct help_area_data
{
	HELP_AREA *	next;
	HELP_DATA *	first;
	HELP_DATA *	last;
	AREA_DATA *	area;
	char *		filename;
};


 




struct	shop_data
{
	SHOP_DATA *	next;			 
	sh_int	keeper;			 
	sh_int	buy_type [5 ];	 
	sh_int	profit_buy;		 
	sh_int	profit_sell;		 
	sh_int	open_hour;		 
	sh_int	close_hour;		 
};

struct spec_type
{
	char * 	name;			 
	SPEC_FUN *	function;		 
};


 


 

struct	note_data
{
	NOTE_DATA *	next;
	GString *	sender;
	GString *	date;
	GString *	to_list;
	GString *	subject;
	GString *	text;
     
	bool	valid;
	time_t	date_stamp;
	sh_int	type;
	time_t  expire;
};

struct item_type
{
	int type;
	char * name;
};

 










 



struct	sphere_data
{
	SPHERE_DATA *	next;
	bool		valid;
	int             spell_number;
	int		type;
	int		duration;
	int		bitvector;
};


 


struct	affect_data
{
	AFFECT_DATA *	next;
	int		type;
	sh_int		duration;
	sh_int		location;
	sh_int		modifier;
	sh_int          where;    
	bool            valid;
	int		bitvector;
};

struct known_data
{
	KNOWN_DATA    *next;
	long           value;
	bool           valid;
};

 







 


struct	kill_data
{
	sh_int		number;
	sh_int		killed;
};



 







 





































 
































 



























 







 






 




 





 
 
 
 



 




 







 


   




















 

























































 







 









 



























 





























 
























 



















 







 

















 
























 
































extern char *scale[4 ];

 
















  




























































 














 









 

























 



 









 











 










 





 






 











 









 





























 





























 
























 


















 
















































 
























 























 

























 




























 







 








 
































 









 










 


















 












 




 








 





























 












 

















 









 
































 









 


















 













 
















 
















 














 






 

















 






 








 








  

                   























 















 



























 









 









 



				 
















		         
			 





 






























 









 
















 










 
























 











































 



struct	mob_index_data
{
	MOB_INDEX_DATA *	next;
	MPROG_LIST *  		mprogs;
	SPEC_FUN *		spec_fun;
	SHOP_DATA *		pShop;
	CHAR_DATA *		mount;
	AREA_DATA *         	area;
	CHAR_DATA *		wizard;
	gchar *		player_name;
	gchar *		short_descr;
	gchar *		long_descr;
	gchar *		description;
	gchar *		lord;
	gchar *		clan;
	gchar *		morph;
	gchar *		createtime;
	gchar *		pload;
	gchar *		lasttime;
	gchar *		lasthost;
	gchar *		powertype;
	gchar *		poweraction;
	gchar *		prompt;
	gchar *		cprompt;
	sh_int		spectype;
	sh_int		specpower;
	int		loc_hp	[7];
	sh_int		vnum;
	sh_int		count;
	sh_int		killed;
	sh_int		sex;
	sh_int		mounted;
	sh_int		home;
	int		       level;
	int			immune;
	int			polyaff;
	int			vampaff;
	int			itemaffect;
	int			vamppass;
	int			form;
	int			act;
	int			extra;
	long			mprog_flags;
	int			affected_by;
	sh_int		alignment;
	sh_int		hitroll;		 
	sh_int		ac;			 
	sh_int		hitnodice;		 
	sh_int		hitsizedice;		 
	int			hitplus;		 
	sh_int		damnodice;		 
	sh_int		damsizedice;		 
	sh_int		damplus;		 
	int			gold;			 
 


	int		added;
	int		mob_fight;
	int 		sphere_spaffect;
	int 		mob_con;

   	 

};



 


struct	char_data
{
	CHAR_DATA *		next;			 
	CHAR_DATA *		next_in_room;	 
	CHAR_DATA *		master;			 
	CHAR_DATA *		leader;			 
	CHAR_DATA *		mob_hunting;	 
	CHAR_DATA *		fighting;
	CHAR_DATA *		mprog_target;
	CHAR_DATA *		reply;
	CHAR_DATA *		mount;
	CHAR_DATA *		wizard;
	CHAR_DATA *		killed_by;		 
	NOTE_DATA *		pnote;
	CHAR_DATA * 	last_attacked;
	OBJ_DATA *		on;
	SPEC_FUN *		spec_fun;
	MOB_INDEX_DATA *	pIndexData;
	DESCRIPTOR_DATA *	desc;
	AFFECT_DATA *		affected;
	SPHERE_DATA *		sphere_affected;
	OBJ_DATA *		carrying;
	ROOM_INDEX_DATA *	in_room;
	ROOM_INDEX_DATA *	was_in_room;
	PC_DATA *		pcdata;
	MEM_DATA *		memory;
	bool		valid;
	GString *		name;
	GString *	        pload;
	GString *	        hunting;
	GString *		short_descr;
	GString *		long_descr;
	GString *		description;
	GString *		lord;
	sh_int		clan;
	sh_int 		sect;  
	GString *		morph;
	GString *		createtime;
	GString *		lasttime;
	GString *		lasthost;
	GString *		poweraction;
	int 		lines;   
	int                 silent_time;
	GString *		powertype;
	GString *		prompt;
	GString *		cprompt;
	int             pk_timer;
	int             attack_timer;
	int             pk_sect;
	sh_int		mprog_delay;
	GString *              prefix;
	GString *              murmur_name;
	long		sight;
	GString *              murmur_command;
	sh_int		sex;
	sh_int		race;
	sh_int		class;
	sh_int		bclass;  
	int		immune;
	int		polyaff;
	int		vampaff_a;
	int		itemaffect;
	int		vamppass_a;
	int		form;
	int		RPts;
	sh_int		vampgen_a;
	sh_int		spectype;
	sh_int		specpower;
	sh_int		loc_hp	[7];
	sh_int		wpn	[13];
	sh_int		spl	[5];
	sh_int		cmbt	[8];
	sh_int		stance	[11];
	sh_int		beast;
	sh_int		mounted;
	sh_int		home;
	sh_int		level;
	sh_int		invis_level;
	sh_int		trust;
	int		played;
	time_t		logon;
	time_t		save_time;
	sh_int		timer;
	sh_int		wait;
	int		pkill;
	sh_int		arete;
	int		pdeath;
	int		mkill;
	int		mdeath;
	int		hit;
	int		max_hit;
	int		mana;
	int		max_mana;
	int		move;
	int		max_move;
	int		gold;
	int		exp;
	sh_int		position;
	sh_int		practice;
    long        primal_hold;
	sh_int		carry_weight;
	sh_int		carry_number;
	sh_int		saving_throw;
	sh_int		alignment;
	int		hitroll;
	int		damroll;
	long		id;
	sh_int		armor;
	sh_int		wimpy;
	long		deaf;
	sh_int		paradox[3];
	int		damcap[2];
	int             dead_time;  
	int             special;
	
	 

	int     sphere_spaffect;
	int     added;
	int		act;
	int		extra;
	int		affected_by;
	int		sphere_affected_by[4];
	int		mob_fight;     
        int 		mob_con;       
	long		plane;     
	 

    	sh_int          delay_timer;	
    	int             rp_status;	
  		CHAR_DATA *     questgiver;          
    	sh_int          nextquest;           
    	sh_int          countdown;           
    	sh_int          questobj;            
    	sh_int          questmob;            
	int 		blood_count;         

	 
	
	 


	
	CHAR_DATA      *pet;             
	int		pet_stats[10];   
	CHAR_DATA      *pet_master;      

};

 


















 


struct	pc_data
{
	PC_DATA *		next;
	CHAR_DATA *		familiar;
	CHAR_DATA *		partner;
	CHAR_DATA *		propose;
	KNOWN_DATA *            known;
	OBJ_DATA *		chobj;
	OBJ_DATA *		memorised;
	BOARD_DATA * 		board;
	NOTE_DATA * 		in_progress;
	 
	time_t		last_note[18 ];
	 
	bool 		valid;
	GString *		pwd;
	GString *		bamfin;
	GString *		bamfout;
	GString *		title;
	GString *		conception;
	GString *		parents;
	GString *		cparents;
	GString *		marriage;
	GString *		email;
	GString *		nature;
	GString *		demeanor;
	GString * 	anon_desc;
	sh_int		perm_str;
	sh_int		perm_int;
	sh_int		perm_wis;
	sh_int		perm_dex;
	sh_int		perm_con;
	sh_int		mod_str;
	sh_int		mod_int;
	sh_int		mod_wis;
	sh_int		mod_dex;
	sh_int		mod_con;
	int		quest;
	int		powers[20];
	int 		stats[12];
	sh_int          discipline[15 ];
	sh_int          inherited[15 ];
	sh_int          Ninherited[40 ];

	sh_int		wolf;
	sh_int		rank;
	sh_int		demonic_a;
	int		language[2];
	sh_int		stage[3];
	sh_int		wolfform[2];
	int		score[6];
	sh_int		runes[4];
	sh_int		disc_a[11];
	int		genes[10];
	sh_int		fake_skill;
	sh_int		fake_stance;
	sh_int		fake_hit;
	sh_int		fake_dam;
	sh_int		fake_hp;
	sh_int		fake_mana;
	sh_int		fake_move;
	int		fake_ac;
	sh_int		obj_vnum;
	sh_int		condition	[3];
	sh_int		learned		[141 ];
	sh_int		stat_ability	[4];
	sh_int		stat_amount	[4];
	sh_int		stat_duration	[4];
	sh_int		exhaustion;
	sh_int      followers;
	bool        confirm_delete;
	int         security;
	int 		vote;
	GString *      alias[20 ];
	GString *      alias_sub[20 ];
	GString *      ignore[4 ];
	GString *      roompose;
	sh_int		charpoints;
	int			trait_merit[2];
	int			trait_flaw[2];
	int 		spent[5];

	 


	sh_int		rage_points;   
	sh_int 		gnosis;        
	sh_int  	renown[3];
	sh_int  	Trenown[3];
	sh_int		wwf_shape;
	sh_int		breed[3];
	sh_int		auspice[5];
	sh_int		tribes[20];
	sh_int		sgift[3];
	int			last_rite;
	sh_int		frenzy_action;
	 

	 
	int			absorb[6];
	sh_int	    willpower;
	int 		comm;		 
	sh_int 		disc[40 ];
	char * 		conding;
	int 		wiznet;  
	int			bodymods;  
	sh_int		diab[2];
	int         obeah;
	int         lag_time;  
	int         hard_skills[10];
	int		ghost_hit;
	int		ghost_mana;
	int 		ghost_move;
	long		ghost_affects;
	int 		ghost_hitroll;
	int		ghost_damroll;
	int 		ghost_ac;
};



 





struct	liq_type
{
	char *	liq_name;
	char *	liq_color;
	sh_int	liq_affect[3];
};





 


struct	extra_descr_data
{
	EXTRA_DESCR_DATA *next;	 
	bool valid;
	char *keyword;               
	char *description;           
};



 


struct	obj_index_data
{
	OBJ_INDEX_DATA *	next;
	EXTRA_DESCR_DATA *	extra_descr;
	AFFECT_DATA *	affected;
	AREA_DATA *  	area;  
	MPROG_LIST *  		mprogs;
	gchar *		name;
	gchar *		short_descr;
	gchar *		description;
	gchar *		chpoweron;
	gchar *		chpoweroff;
	gchar *		chpoweruse;
	gchar *		victpoweron;
	gchar *		victpoweroff;
	gchar *		victpoweruse;
	gchar *		questmaker;
	gchar *      page_content;
	gchar *		questowner;
	sh_int		vnum;
	sh_int		item_type;
	sh_int		extra_flags;
	sh_int		wear_flags;
	sh_int		count;
	sh_int		weight;
	sh_int		reset_num;
	int			spectype;
	int			specpower;
	sh_int		condition;
	sh_int		toughness;
	sh_int		resistance;
	int			quest;
	sh_int		points;
	int			cost;			 
	int			value	[4];
	long	  	mprog_flags;	 
	
};



 


struct	obj_data
{
	OBJ_DATA *		next_content;
	OBJ_DATA *		contains;
	OBJ_DATA *		in_obj;
	OBJ_DATA *		on;
	CHAR_DATA *		carried_by;
	CHAR_DATA *		chobj;
	EXTRA_DESCR_DATA *	extra_descr;
	AFFECT_DATA *	affected;
	OBJ_INDEX_DATA *	pIndexData;
	ROOM_INDEX_DATA *	in_room;
	CHAR_DATA *		mprog_target;
	sh_int		mprog_delay;
	bool            valid;
	GString *		name;
	GString *		short_descr;
	GString *		description;
	GString *		chpoweron;
	GString *		chpoweroff;
	GString *		chpoweruse;
	GString *		victpoweron;
	GString *		victpoweroff;
	GString *          owner;
	GString *		victpoweruse;
	GString *		questmaker;
	GString *		questowner;
	GString *      page_content;
	GString * 		OOwner;
	sh_int		item_type;
	int		extra_flags;
	sh_int		wear_flags;
	sh_int		wear_loc;
	sh_int		weight;
	int		spectype;
	int		specpower;
	sh_int		condition;
	sh_int		toughness;
	sh_int		resistance;
	int		quest;
	sh_int		points;
	int		cost;
	sh_int		level;
	sh_int		timer;
	int		value	[4];
	sh_int          sphere[9 ];
	long		last_seen_on;    
	int 		plane;
};



 


struct	exit_data
{
	union                               
	{
		ROOM_INDEX_DATA *	to_room;
		sh_int		vnum;
	} u1;
	ROOM_INDEX_DATA *	to_room;
	sh_int		vnum;
	
	sh_int		exit_info;
	sh_int		key;
	char *		keyword;
	char *		description;
	EXIT_DATA *         next;  
	int                 rs_flags;  
	int                 orig_door;  
};



 


typedef struct roomtext_data
{
	int				type;
	int				power;
	int				mob;
	char *			input;
	char *			output;
	char *			choutput;
	char *			name;
	struct roomtext_data	*next;
} ROOMTEXT_DATA;



 












 


struct	reset_data
{
	char		command;
	sh_int		arg1;
	sh_int		arg2;
	sh_int		arg3;
	sh_int		arg4;
};



 


struct	area_data
{
	AREA_DATA *	next;
	RESET_DATA *	reset_first;
	RESET_DATA *	reset_last;
	HELP_AREA *     helps;   
	gchar *		name;
	gchar *		file_name;
	gchar *		test_name;
	sh_int		age;
	sh_int		nplayer;
	int             min_vnum;
	int             max_vnum;
	gchar *		builders; 
	gchar *		credits;  
	bool 		empty;    
	int		vnum;
	int		area_flags;
	int		security;      
	
};



 


struct	room_index_data
{
	ROOM_INDEX_DATA *	next;
	CHAR_DATA *		people;
	OBJ_DATA *		contents;
	EXTRA_DESCR_DATA *	extra_descr;
	AREA_DATA *		area;
	EXIT_DATA *		exit	  [6];
	GSList *	reset_list;  
	ROOMTEXT_DATA *	roomtext;
	AFFECT_DATA *       affected; 
	MPROG_LIST *  		mprogs;
	CHAR_DATA *		mprog_target;
	sh_int		mprog_delay;
	int 		affected_by;
	GString *	track     [5];
	gchar *		name;
	gchar *		owner;
	gchar *		description;
	sh_int		vnum;
	int		        room_flags;
	sh_int		light;
	sh_int		blood;
	sh_int		track_dir [5];
	long	  	mprog_flags;	 
	sh_int		sector_type;
};

 

struct mprog_list
{
	int				trig_type;
	GString *			trig_phrase;
	sh_int			vnum;
	GString *  		code;
	MPROG_LIST * 	next;
	bool           	valid;
};

struct mprog_code
{
	sh_int			vnum;
	GString *			code;
	MPROG_CODE *	next;
	bool           	valid;
};

 































 
















 


struct	skill_type
{
	char *	name;			 
	sh_int	skill_level;	         
	SPELL_FUN *	spell_fun;		 
	sh_int	target;			 
	sh_int	minimum_position;	 
	sh_int *	pgsn;			 
	sh_int	slot;			 
	sh_int	min_mana;		 
	sh_int	beats;			 
	char *	noun_damage;		 
	char *	msg_off;		 
	sh_int	bclass;          
};

struct	discipline_type
{
	char *	name;		 
	char *	name_caps;	 
	char *      powers;          
};

struct	spell_colour_type
{
	char *	name;
	char *	colour;
};

struct mage_clan_type
{
	char *	name;		 
	sh_int	sect;		 
	int	sphere;		 
	int     iclan_number;
	char *	lineage;	 
	char *  pretty_name;
};

struct vamp_clan_type
{
	char *	name;		 
	int     iclan_number;
	char *	sect;		 
	int		discipline[3];	 
	char *	lineage;	 
};

struct tribe_type
{
	char * tribe_name;
	int     iclan_number;
	char * tribe_sect;
	int    tribe_real_name;
	char * tribe_pretty_name; 
};

 


extern  sh_int  gsn_potency;
extern	sh_int	gsn_agg_damage;
extern	sh_int	gsn_backstab;
extern	sh_int	gsn_tail;
extern	sh_int	gsn_hunt;
extern	sh_int	gsn_hide;
extern	sh_int	gsn_peek;
extern	sh_int	gsn_pick_lock;
extern	sh_int	gsn_sneak;
extern	sh_int	gsn_steal;
extern	sh_int	gsn_weaken;
extern	sh_int	gsn_silent;

extern	sh_int	gsn_fastdraw;
extern	sh_int	gsn_berserk;
extern	sh_int	gsn_punch;
extern	sh_int	gsn_stomp;
extern	sh_int	gsn_elbow;
extern	sh_int	gsn_headbutt;
extern	sh_int	gsn_sweep;
extern	sh_int	gsn_knee;
extern	sh_int	gsn_disarm;
extern	sh_int	gsn_hurl;
extern	sh_int	gsn_kick;
extern	sh_int	gsn_rescue;
extern	sh_int	gsn_track;
extern	sh_int	gsn_polymorph;
extern	sh_int	gsn_web;
extern	sh_int	gsn_arm;
extern	sh_int	gsn_fear;

extern	sh_int	gsn_blindness;
extern	sh_int	gsn_charm_person;
extern	sh_int	gsn_curse;
extern	sh_int	gsn_invis;
extern	sh_int	gsn_mass_invis;
extern	sh_int	gsn_poison;
extern	sh_int	gsn_plague;
extern	sh_int	gsn_sleep;

extern	sh_int	gsn_paradox;
extern	sh_int	gsn_darkness;
extern	sh_int	gsn_bash;


 















 






































 



















































 








 










 


struct	cmd_type
{
	char * const	name;
	DO_FUN *		do_fun;
	sh_int		position;
	sh_int		level;
	sh_int		log;
};



 


struct	social_type
{
	char  	name[20];
	char * 	char_no_arg;
	char *	others_no_arg;
	char * 	char_found;
	char * 	others_found;
	char *	vict_found;
	char *      char_not_found;
	char *	char_auto;
	char *	others_auto;
};

extern int riddle_max;
extern int riddle_number;

struct  riddle_type
{
	char *	riddle;
	char *  clue;
	char *  clue_do;
	char *  answer;
	char *  answer_do;
};


 


struct	xsocial_type
{
	char * 	name;
	char * 	char_no_arg;
	char * 	others_no_arg;
	char * 	char_found;
	char * 	others_found;
	char * 	vict_found;
	char * 	char_auto;
	char * 	others_auto;
	char * 	msp;
	sh_int		gender;
	sh_int		stage;
	sh_int		position;
	sh_int		self;
	sh_int		other;
	bool		chance;
};



 


extern	const	struct	str_app_type	str_app		[26];
extern	const	struct	int_app_type	int_app		[26];
extern	const	struct	wis_app_type	wis_app		[26];
extern	const	struct	dex_app_type	dex_app		[26];
extern	const	struct	con_app_type	con_app		[26];

extern	const	struct	cmd_type	cmd_table	[];
extern	const	struct	liq_type	liq_table	[16 ];
extern	const	struct	skill_type	skill_table	[];
extern		struct	clan_table_type	clan_table	[11 ];
extern		struct	artifact_type	artifact_table	[21 ];
extern		struct	social_type	social_table	[500 ];
extern		struct  riddle_type	riddle_table	[200 ];
extern		struct	xsocial_type	xsocial_table	[500 ];
extern  const   struct  discipline_type discipline_table        [40 ];
extern  const   struct  spell_colour_type spell_colour_table        [5];
extern  const   struct  vamp_clan_type  vamp_clan_table [29 ];
extern  const   struct  mage_clan_type  mage_clan_table [];




 


extern		HELP_DATA	  *	help_first;
extern		SHOP_DATA	  *	shop_first;

extern		BAN_DATA	  *	ban_list;
extern		CHAR_DATA	  *	char_list;
extern		GSList   	  *descriptor_list;
extern		NOTE_DATA	  *	note_list;
extern		GSList	  	  * object_list;
extern		MPROG_CODE	  *	mprog_list;
extern		AFFECT_DATA	  *	affect_free;
extern		BAN_DATA	  *	ban_free;
extern		CHAR_DATA	  *	char_free;
extern		GSList	      * object_free;
extern		GSList	      *	descriptor_free;
extern		GSList  *	extra_descr_free;
extern		ROOMTEXT_DATA     *	roomtext_free;
extern		NOTE_DATA	  *	note_free;
extern		GSList	  *	obj_free;
extern		PC_DATA		  *	pcdata_free;

extern		char			bug_buf		[];
extern		time_t			current_time;
extern		bool			fLogAll;
extern		FILE *			fpReserve;
extern		KILL_DATA		kill_table	[];
extern		char			log_buf		[];
extern		TIME_INFO_DATA		time_info;
extern		char 			last_command[4096 ];
extern		MUD_SETTING		*mudsetting;
extern		bool			MOBtrigger;

 



SPELL_FUN  	spell_null		  ;
SPELL_FUN  	spell_acid_blast	  ;
SPELL_FUN  	spell_armor		  ;
SPELL_FUN  	spell_bless		  ;
SPELL_FUN  	spell_blindness		  ;
SPELL_FUN  	spell_burning_hands	  ;
SPELL_FUN  	spell_call_lightning	  ;
SPELL_FUN  	spell_cause_critical	  ;
SPELL_FUN  	spell_cause_light	  ;
SPELL_FUN  	spell_cause_serious	  ;
SPELL_FUN  	spell_change_sex	  ;
SPELL_FUN  	spell_charm_person	  ;
SPELL_FUN  	spell_chill_touch	  ;
SPELL_FUN  	spell_colour_spray	  ;
SPELL_FUN  	spell_continual_light	  ;
SPELL_FUN  	spell_control_weather	  ;
SPELL_FUN  	spell_create_food	  ;
SPELL_FUN  	spell_create_spring	  ;
SPELL_FUN  	spell_create_water	  ;
SPELL_FUN  	spell_cure_blindness	  ;
SPELL_FUN  	spell_cure_critical	  ;
SPELL_FUN  	spell_cure_light	  ;
SPELL_FUN  	spell_cure_poison	  ;
SPELL_FUN  	spell_cure_serious	  ;
SPELL_FUN  	spell_curse		  ;
SPELL_FUN  	spell_detect_evil	  ;
SPELL_FUN  	spell_detect_hidden	  ;
SPELL_FUN  	spell_detect_invis	  ;
SPELL_FUN  	spell_detect_magic	  ;
SPELL_FUN  	spell_detect_poison	  ;
SPELL_FUN  	spell_dispel_evil	  ;
SPELL_FUN  	spell_dispel_magic	  ;
SPELL_FUN  	spell_earthquake	  ;
SPELL_FUN  	spell_enchant_weapon	  ;
SPELL_FUN  	spell_energy_drain	  ;
SPELL_FUN  	spell_faerie_fire	  ;
SPELL_FUN  	spell_faerie_fog	  ;
SPELL_FUN  	spell_fireball		  ;
SPELL_FUN  	spell_flamestrike	  ;
SPELL_FUN  	spell_fly		  ;
SPELL_FUN  	spell_gate		  ;
SPELL_FUN  	spell_general_purpose	  ;
SPELL_FUN  	spell_giant_strength	  ;
SPELL_FUN  	spell_harm		  ;
SPELL_FUN  	spell_heal		  ;
SPELL_FUN  	spell_high_explosive	  ;
SPELL_FUN  	spell_identify		  ;
SPELL_FUN  	spell_infravision	  ;
SPELL_FUN  	spell_invis		  ;
SPELL_FUN  	spell_know_alignment	  ;
SPELL_FUN  	spell_lightning_bolt	  ;
SPELL_FUN  	spell_locate_object	  ;
SPELL_FUN  	spell_fear			  ;
SPELL_FUN  	spell_magic_missile	  ;
SPELL_FUN  	spell_mass_invis	  ;
SPELL_FUN  	spell_pass_door		  ;
SPELL_FUN  	spell_poison		  ;
SPELL_FUN  	spell_plague 		  ;
SPELL_FUN  	spell_cure_disease	  ;
SPELL_FUN  	spell_protection	  ;
SPELL_FUN  	spell_refresh		  ;
SPELL_FUN  	spell_remove_curse	  ;
SPELL_FUN  	spell_sanctuary		  ;
SPELL_FUN  	spell_shocking_grasp	  ;
SPELL_FUN  	spell_shield		  ;
SPELL_FUN  	spell_sleep		  ;
SPELL_FUN  	spell_stone_skin	  ;
SPELL_FUN  	spell_summon		  ;
SPELL_FUN  	spell_teleport		  ;
SPELL_FUN  	spell_ventriloquate	  ;
SPELL_FUN  	spell_weaken		  ;
SPELL_FUN  	spell_word_of_recall	  ;
SPELL_FUN  	spell_acid_breath	  ;
SPELL_FUN  	spell_fire_breath	  ;
SPELL_FUN  	spell_frost_breath	  ;
SPELL_FUN  	spell_gas_breath	  ;
SPELL_FUN  	spell_lightning_breath	  ;

SPELL_FUN  	spell_guardian		  ;
SPELL_FUN  	spell_soulblade		  ;
SPELL_FUN  	spell_mana		  ;
SPELL_FUN  	spell_frenzy		  ;
SPELL_FUN  	spell_darkblessing	  ;
SPELL_FUN  	spell_portal		  ;
SPELL_FUN  	spell_energyflux	  ;
SPELL_FUN  	spell_voodoo		  ;
SPELL_FUN  	spell_transport		  ;
SPELL_FUN  	spell_regenerate	  ;
SPELL_FUN  	spell_clot		  ;
SPELL_FUN  	spell_mend		  ;
SPELL_FUN  	spell_quest		  ;
SPELL_FUN  	spell_minor_creation	  ;
SPELL_FUN  	spell_brew		  ;
SPELL_FUN  	spell_scribe		  ;
SPELL_FUN  	spell_carve		  ;
SPELL_FUN  	spell_engrave		  ;
SPELL_FUN  	spell_bake		  ;
SPELL_FUN  	spell_mount		  ;
SPELL_FUN  	spell_scan		  ;
SPELL_FUN  	spell_repair		  ;
SPELL_FUN  	spell_spellproof	  ;
SPELL_FUN  	spell_preserve		  ;
SPELL_FUN  	spell_perfection	  ;
SPELL_FUN  	spell_major_creation	  ;
SPELL_FUN  	spell_copy		  ;
SPELL_FUN  	spell_insert_page	  ;
SPELL_FUN  	spell_chaos_blast	  ;
SPELL_FUN  	spell_resistance	  ;
SPELL_FUN  	spell_web		  ;
SPELL_FUN  	spell_arm		  ;
SPELL_FUN  	spell_polymorph	  ;
SPELL_FUN  	spell_contraception	  ;
SPELL_FUN  	spell_remove_page	  ;
SPELL_FUN  	spell_find_familiar	  ;
SPELL_FUN  	spell_improve		  ;

 






















char *	crypt		  ( const char *key, const char *salt )   ;







char *	crypt		  ( const char *key, const char *salt )   ;

















# 3574 "../include/merc.h"


# 3589 "../include/merc.h"








 











 














































  


 











 
void    page_to_char	  ( const char *txt, CHAR_DATA *ch )   ;
void	show_string	  ( struct descriptor_data *d, char *input)   ;
void	add_follower	  ( CHAR_DATA *ch, CHAR_DATA *master )   ;
void	stop_follower	  ( CHAR_DATA *ch )   ;
bool	check_pk	  ( CHAR_DATA *ch, CHAR_DATA *victim, int flag )   ;
bool	check_pk_range	  ( CHAR_DATA *ch, CHAR_DATA *victim )   ;
void	die_follower	  ( CHAR_DATA *ch )   ;
bool	is_same_group	  ( CHAR_DATA *ach, CHAR_DATA *bch )   ;
void	room_text	  ( CHAR_DATA *ch, char *argument )   ;
char    *strlower         ( char * ip )   ;
void	excessive_cpu	  ( int blx )   ;
bool	check_parse_name   ( char *name )   ;
bool    write_to_descriptor  (int desc,char *txt,int lenght )  ;

 
int	get_hours	  ( CHAR_DATA *ch )   ;
void	set_title	  ( CHAR_DATA *ch, char *title )   ;
char    *PERS             ( CHAR_DATA *ch, CHAR_DATA *viewer)   ;
bool    knows_char        ( CHAR_DATA *ch, CHAR_DATA *victim)   ;
void    add_known         ( CHAR_DATA *ch, CHAR_DATA *victim)   ;
char    *unknown_name     ( CHAR_DATA *ch, CHAR_DATA *viewer)   ;
void	show_list_to_char	  ( OBJ_DATA *list, CHAR_DATA *ch,
		bool fShort, bool fShowNothing )   ;
int	char_hitroll	  ( CHAR_DATA *ch )   ;
int	char_damroll	  ( CHAR_DATA *ch )   ;
int	char_ac		  ( CHAR_DATA *ch )   ;
void	playwave_toroom	  ( CHAR_DATA *ch, int wavnum )   ;
void	playwave_toch	  ( CHAR_DATA *ch, int wavnum )   ;
int	get_breed	  ( CHAR_DATA *ch, int disc )   ;
int	get_auspice	  ( CHAR_DATA *ch, int disc )   ;
int	get_tribe	  ( CHAR_DATA *ch, int disc )   ;


 
void	move_char	  ( CHAR_DATA *ch, int door )   ;
void	open_lift	  ( CHAR_DATA *ch )   ;
void	close_lift	  ( CHAR_DATA *ch )   ;
void	move_lift	  ( CHAR_DATA *ch, int to_room )   ;
void	move_door	  ( CHAR_DATA *ch )   ;
void	thru_door	  ( CHAR_DATA *ch, int doorexit )   ;
void	open_door	  ( CHAR_DATA *ch, bool be_open )   ;
bool	is_open		  ( CHAR_DATA *ch )   ;
bool	same_floor	  ( CHAR_DATA *ch, int cmp_room )   ;
void	check_hunt	  ( CHAR_DATA *ch )   ;
void    check_pet_reaction  (CHAR_DATA *pet)  ;

 
CHAR_DATA  *	find_keeper	  ( CHAR_DATA *ch )   ;
bool	is_ok_to_wear	  ( CHAR_DATA *ch, bool wolf_ok, char *argument )   ;
void	quest_object	  ( CHAR_DATA *ch, OBJ_DATA *obj )   ;
bool	remove_obj	  ( CHAR_DATA *ch, int iWear, bool fReplace )   ;
void	wear_obj	  ( CHAR_DATA *ch, OBJ_DATA *obj, bool fReplace )   ;
void 	create_zombie   ( OBJ_DATA *obj )   ;

 
void	bind_char	  ( CHAR_DATA *ch  )   ;
 
void	do_gen_info	  ( char *argument )   ;
void	play_wave	  ( int  wavnum    )   ;
void 	logchan		  (char *string, CHAR_DATA *ch, OBJ_DATA *obj,
			       long flag, long flag_skip, int min_level )   ;
void 	check_mobile   ( char *argument )   ;

 
void    substitute_alias   (DESCRIPTOR_DATA *d, char *input)   ;

 
void	close_socket	  ( DESCRIPTOR_DATA *dclose )   ;
void	close_socket2	  ( DESCRIPTOR_DATA *dclose, bool kickoff )   ;
void	write_to_buffer	  ( DESCRIPTOR_DATA *d, const char *txt,
		int length )   ;
void	send_to_char	  ( const char *txt, CHAR_DATA *ch )   ;
void	act		  ( const char *format, CHAR_DATA *ch,
		const void *arg1, const void *arg2, int type )   ;
void	act2		  ( const char *format, CHAR_DATA *ch,
		const void *arg1, const void *arg2, int type )   ;
void	kavitem		  ( const char *format, CHAR_DATA *ch,
		const void *arg1, const void *arg2, int type )   ;
void	ch_printf	  ( CHAR_DATA *ch, char *fmt, ... )   ;
void    mxpconv       ( GString *output, const char *txt, CHAR_DATA *ch )   ;
void 	frenzy_colour    ( char type, CHAR_DATA *ch, GString *string )   ;

 


void	colour		  ( char type, CHAR_DATA *ch, GString *string )   ;
void	colourconv	  ( GString *buffer, GString *txt, CHAR_DATA *ch )   ;
void	send_to_char_bw	  ( const char *txt, CHAR_DATA *ch )   ;


 

size_t			nAllocString;
int			sAllocString;
int			nAllocPerm;
size_t			sAllocPerm;
void	str_cpy   ( char *dest, char *src )   ;


extern unsigned strspace_size;  
char* strspace_alloc();
void  strspace_size_increment();
extern size_t   nAllocString;
extern int      sAllocString;   
extern int      social_count;


char *  print_flags       ( int flag )  ;
void	reset_area        ( AREA_DATA * pArea )   ;		 
void	reset_room	  ( ROOM_INDEX_DATA *pRoom )   ;	 
void	boot_db		  ( void )   ;
long	get_pc_id	  ( void )   ;
long	get_mob_id	  ( void )   ;
void	area_update	  ( void )   ;
CHAR_DATA  *	create_mobile	  ( MOB_INDEX_DATA *pMobIndex )   ;
OBJ_DATA  *	create_object	  ( OBJ_INDEX_DATA *pObjIndex, int level )   ;
void	clear_char	  ( CHAR_DATA *ch )   ;
void	free_char	  ( CHAR_DATA *ch )   ;
char *	get_extra_descr	  ( char *name, EXTRA_DESCR_DATA *ed )   ;
char *	get_roomtext	  ( const char *name, ROOMTEXT_DATA    *rt )   ;
MOB_INDEX_DATA  *	get_mob_index	  ( int vnum )   ;
OBJ_INDEX_DATA  *	get_obj_index	  ( int vnum )   ;
ROOM_INDEX_DATA  *	get_room_index	  ( int vnum )   ;
char	fread_letter	  ( FILE *fp )   ;
MPROG_CODE  *	get_mprog_index   ( int vnum )   ;
int	fread_number	  ( FILE *fp )   ;
long    fread_flag        ( FILE *fp )   ;
char *	fread_string	  ( FILE *fp )   ;
GString *nonfread_string	  ( GString *string,FILE *fp )   ;
void	fread_to_eol	  ( FILE *fp )   ;
char *	fread_word	  ( FILE *fp )   ;
 




char *	str_dup		  ( const char *str )   ;
void	free_string	  ( char *pstr )   ;
int	number_fuzzy	  ( int number )   ;
int	number_range	  ( int from, int to )   ;
int	number_percent	  ( void )   ;
int	number_door	  ( void )   ;
int	number_bits	  ( int width )   ;
int	number_mm	  ( void )   ;
int	dice		  ( int number, int size )   ;
int	interpolate	  ( int level, int value_00, int value_32 )   ;
void	smash_tilde	  ( char *str )   ;
void	smash_quote	  ( char *str )   ;
void	smash_CRLF	  ( char *str )   ;
bool	str_cmp		  ( const char *astr, const char *bstr )   ;
bool	str_prefix	  ( const char *astr, const char *bstr )   ;
bool	str_infix	  ( const char *astr, const char *bstr )   ;
bool	str_suffix	  ( const char *astr, const char *bstr )   ;
char *	capitalize	  ( const char *str )   ;
void	append_file	  ( CHAR_DATA *ch, char *file, char *str )   ;
void	bug		  ( const char *str, int param )   ;
void	log_string2	  ( const char *str )   ;
void	tail_chain	  ( void )   ;
 
bool 	check_disc    (CHAR_DATA *ch, CHAR_DATA *victim, int flag)  ;

 
void    put_stance   (CHAR_DATA *ch)  ;
void	violence_update	  ( void )   ;
void	multi_hit	  ( CHAR_DATA *ch, CHAR_DATA *victim, int dt )   ;
void	damage		  ( CHAR_DATA *ch, CHAR_DATA *victim, int dam,
		int dt )   ;
void	adv_damage	  ( CHAR_DATA *ch, CHAR_DATA *victim, int dam )   ;
void	update_pos	  ( CHAR_DATA *victim )   ;
void	stop_fighting	  ( CHAR_DATA *ch, bool fBoth )   ;
bool	no_attack	  ( CHAR_DATA *ch, CHAR_DATA *victim )   ;
void	set_attack_flag	  ( CHAR_DATA *ch, CHAR_DATA *victim )   ;
void	check_pkstatus 	  ( CHAR_DATA *ch, CHAR_DATA *victim )   ;
bool	is_safe		  ( CHAR_DATA *ch, CHAR_DATA *victim )   ;
bool	is_tempsafe	  ( CHAR_DATA *ch )   ;
void	hurt_person	  ( CHAR_DATA *ch, CHAR_DATA *victim, int dam )   ;
 
void	group_gain	  ( CHAR_DATA *ch, CHAR_DATA *victim )   ;
int	dambonus	  ( CHAR_DATA *ch, CHAR_DATA *victim, 
			    int dam, int stance)   ;
bool 	check_safe_imm   (CHAR_DATA *ch)  ;
 
int    check_follower_count  (CHAR_DATA *ch)  ;
bool	is_in		  (char *, char *)   ;
bool	is_inpref		  (char *, char *)   ;
bool	all_in		  (char *, char *)   ;
bool    is_same_plane     ( CHAR_DATA *ch, CHAR_DATA *victim)   ;
char    *act_bit_name     ( int act_flags )   ;
char    *fight_bit_name     ( int act_flags )   ;
char    *attack_bit_name     ( int act_flags )   ;
char    *added_bit_name     ( int vector )   ;
char    *spaffect_bit_name     ( int vector )   ;
char    *comm_bit_name     ( int vector )   ;
AFFECT_DATA *find_affect   ( CHAR_DATA *ch, int bitvector )   ;
SPHERE_DATA *find_spaffect   ( CHAR_DATA *ch, int bitvector )   ;
int	get_trust	  ( CHAR_DATA *ch )   ;
int	get_age		  ( CHAR_DATA *ch )   ;
void	shift_obj_plane  (CHAR_DATA *ch)  ;
int	get_curr_str	  ( CHAR_DATA *ch )   ;
int	get_curr_int	  ( CHAR_DATA *ch )   ;
int	get_curr_wis	  ( CHAR_DATA *ch )   ;
int	get_curr_dex	  ( CHAR_DATA *ch )   ;
int	get_curr_con	  ( CHAR_DATA *ch )   ;
int	can_carry_n	  ( CHAR_DATA *ch )   ;
int	can_carry_w	  ( CHAR_DATA *ch )   ;
void	set_mob_stance	  ( CHAR_DATA *ch )   ;
void	set_random_stance	  ( CHAR_DATA *ch )   ;
void	set_master_stance	  ( CHAR_DATA *ch )   ;
bool	is_name		  ( char *str, char *namelist )   ;
bool	is_full_name	  ( const char *str, char *namelist )   ;
bool	is_exact_name	  ( char *str, char *namelist )   ;
void	affect_to_char	  ( CHAR_DATA *ch, AFFECT_DATA *paf )   ;
void	sphere_to_char	  ( CHAR_DATA *ch, SPHERE_DATA *paf )   ;
void	affect_to_obj	  ( OBJ_DATA *obj, AFFECT_DATA *paf )   ;
void	affect_to_room	  ( ROOM_INDEX_DATA *room, AFFECT_DATA *paf )   ;
void	affect_remove	  ( CHAR_DATA *ch, AFFECT_DATA *paf )   ;
void	sphere_remove	  ( CHAR_DATA *ch, SPHERE_DATA *paf )   ;
void	affect_remove_obj   ( OBJ_DATA *obj, AFFECT_DATA *paf )   ;
void	affect_strip	  ( CHAR_DATA *ch, int sn )   ;
bool	is_affected	  ( CHAR_DATA *ch, int sn )   ;
void	affect_join	  ( CHAR_DATA *ch, AFFECT_DATA *paf )   ;
void	char_from_room	  ( CHAR_DATA *ch )   ;
void	char_to_room	  ( CHAR_DATA *ch, ROOM_INDEX_DATA *pRoomIndex )   ;
void	obj_to_char	  ( OBJ_DATA *obj, CHAR_DATA *ch )   ;
void	obj_from_char	  ( OBJ_DATA *obj )   ;
int	apply_ac	  ( OBJ_DATA *obj, int iWear )   ;
OBJ_DATA  *	get_eq_char	  ( CHAR_DATA *ch, int iWear )   ;
void	equip_char	  ( CHAR_DATA *ch, OBJ_DATA *obj, int iWear )   ;
void	unequip_char	  ( CHAR_DATA *ch, OBJ_DATA *obj )   ;
int	count_obj_list	  ( OBJ_INDEX_DATA *obj, OBJ_DATA *list )   ;
void	obj_from_room	  ( OBJ_DATA *obj )   ;
void	obj_to_room	  ( OBJ_DATA *obj, ROOM_INDEX_DATA *pRoomIndex )   ;
void	obj_to_obj	  ( OBJ_DATA *obj, OBJ_DATA *obj_to )   ;
void	obj_from_obj	  ( OBJ_DATA *obj )   ;
void	extract_obj	  ( OBJ_DATA *obj )   ;
void	extract_char	  ( CHAR_DATA *ch, bool fPull )   ;
CHAR_DATA  *	get_char_room	  ( CHAR_DATA *ch, char *argument )   ;
CHAR_DATA  *    get_char_world    ( CHAR_DATA *ch, char *argument )   ;
CHAR_DATA  *    get_char_id       ( long id )   ;
CHAR_DATA  *    get_char_world2   ( CHAR_DATA *ch, char *argument )   ;
CHAR_DATA  *    get_char_area     ( CHAR_DATA *ch, char *argument )   ;
OBJ_DATA  *	get_obj_type	  ( OBJ_INDEX_DATA *pObjIndexData )   ;
OBJ_DATA  *	get_obj_list	  ( CHAR_DATA *ch, char *argument,
		OBJ_DATA *list )   ;
OBJ_DATA  *	get_obj_in_obj	  ( CHAR_DATA *ch, char *argument )   ;
OBJ_DATA  *	get_obj_carry	  ( CHAR_DATA *ch, char *argument )   ;
OBJ_DATA  *	get_obj_wear	  ( CHAR_DATA *ch, char *argument )   ;
OBJ_DATA  *	get_obj_here	  ( CHAR_DATA *ch, char *argument )   ;
OBJ_DATA  *	get_obj_room	  ( CHAR_DATA *ch, char *argument )   ;
OBJ_DATA  *	get_obj_world	  ( CHAR_DATA *ch, char *argument )   ;
OBJ_DATA  *	get_obj_world2	  ( CHAR_DATA *ch, char *argument )   ;
OBJ_DATA  *	create_money	  ( int amount )   ;
int	get_obj_number	  ( OBJ_DATA *obj )   ;
int	get_obj_weight	  ( OBJ_DATA *obj )   ;
bool	room_is_dark	  ( ROOM_INDEX_DATA *pRoomIndex )   ;
bool	room_is_private	  ( ROOM_INDEX_DATA *pRoomIndex )   ;
bool	can_see		  ( CHAR_DATA *ch, CHAR_DATA *victim )   ;
bool	has_planesight	  ( CHAR_DATA *ch, CHAR_DATA *victim )   ;
bool	can_see_obj	  ( CHAR_DATA *ch, OBJ_DATA *obj )   ;
bool	can_drop_obj	  ( CHAR_DATA *ch, OBJ_DATA *obj )   ;
char *	item_type_name	  ( OBJ_DATA *obj )   ;
char *	affect_loc_name	  ( int location )   ;
char *	affect_bit_name	  ( int vector )   ;
char *	extra_bit_name	  ( int extra_flags )   ;
void	affect_modify	  ( CHAR_DATA *ch, AFFECT_DATA *paf, bool fAdd )   ;
void	sphere_modify	  ( CHAR_DATA *ch, SPHERE_DATA *paf, bool fAdd )   ;
void	affect_remove_room	  ( ROOM_INDEX_DATA *room, AFFECT_DATA *paf )   ;
void 	strip_player   ( CHAR_DATA *ch )   ;
long	wiznet_lookup	  ( const char *name)   ;

 
void	interpret	  ( CHAR_DATA *ch, char *argument )   ;
bool	is_number	  ( char *arg )   ;
int	number_argument	  ( char *argument, char *arg )   ;
char *	one_argument	  ( char *argument, char *arg_first )   ;
void	stage_update	  ( CHAR_DATA *ch, CHAR_DATA *victim, int stage )   ;
bool	check_social	  ( CHAR_DATA *ch, char *command,
	char *argument )   ;


int	discipline_lookup   ( const char *discipline )   ;
int	vamp_clan_lookup   ( const char *vamp_clan )   ;
int	mage_clan_lookup   ( const char *mage_clan )   ;
 
int     mage_affect_slot   (char * command)   ;
int	skill_lookup	  ( const char *name )   ;
int	slot_lookup	  ( int slot )   ;
bool	saves_spell	  ( int level, CHAR_DATA *victim )   ;
void	obj_cast_spell	  ( int sn, int level, CHAR_DATA *ch,
		CHAR_DATA *victim, OBJ_DATA *obj )   ;
void	enhance_stat	  ( int sn, int level, CHAR_DATA *ch, 
		CHAR_DATA *victim, int apply_bit,
		int bonuses, int affect_bit )   ;
void    set_rObjNest_null  ()  ;
		
 
void	save_char_obj		  ( CHAR_DATA *ch )   ;
void	save_char_obj_backup	  ( CHAR_DATA *ch )   ;
bool	load_char_obj		  ( DESCRIPTOR_DATA *d, char *name )   ;
bool	load_char_short		  ( DESCRIPTOR_DATA *d, char *name )   ;

 
SPEC_FUN  *	spec_lookup	  ( const char *name )   ;
char  *spec_name	  ( SPEC_FUN *function )   ;

 
void	gain_exp	  ( CHAR_DATA *ch, int gain )   ;
void	gain_condition	  ( CHAR_DATA *ch, int iCond, int value )   ;
void	update_handler	  ( void )   ;
bool    hates_players     ( CHAR_DATA *ch, CHAR_DATA *victim )   ;

 
void	special_move	  ( CHAR_DATA *ch, CHAR_DATA *victim )   ;

 
void	birth_date	  ( CHAR_DATA *ch, bool is_self )   ;
void	other_age	  ( CHAR_DATA *ch, int extra, bool is_preg, 
		char *argument )   ;
int	years_old	  ( CHAR_DATA *ch )   ;

 
void oset_affect   ( CHAR_DATA *ch, OBJ_DATA *obj, int value, int affect, bool is_quest)   ;

 
void	werewolf_regen	  ( CHAR_DATA *ch )   ;
void	reg_mend	  ( CHAR_DATA *ch )   ;
void	vamp_rage	  ( CHAR_DATA *ch )   ;
bool	char_exists	  ( bool backup, char *argument )   ;
int	get_disc	  ( CHAR_DATA *ch, int discipline)   ;
int	get_disc	  ( CHAR_DATA *ch, int discipline)   ;
int	has_sphere	  ( CHAR_DATA *ch, int discipline)   ;
OBJ_DATA  *	get_page	  ( OBJ_DATA *book, int page_num )   ;

  
void	program_flow	  ( sh_int vnum, char *source, CHAR_DATA *mob, CHAR_DATA *ch,
		const void *arg1, const void *arg2 )   ;
void	mp_act_trigger	  ( char *argument, CHAR_DATA *mob, CHAR_DATA *ch, const void *arg1, const void *arg2, int type )   ;

void    rprog_act_trigger  ( char *argument, ROOM_INDEX_DATA *pRoom, CHAR_DATA *ch, void *arg1, void *arg2, int type)  ;
void    oprog_act_trigger  ( char *argument, OBJ_DATA *obj, CHAR_DATA *ch, void *arg1, void *arg2, int type)  ;

bool	rprog_percent_trigger   ( ROOM_INDEX_DATA *pRoom, CHAR_DATA *ch, const void *arg1, const void *arg2, int type )   ;
bool	oprog_percent_trigger   ( OBJ_DATA *obj, CHAR_DATA *ch, const void *arg1, const void *arg2, int type )   ;

void	mp_riddle_trigger	  ( char *argument, CHAR_DATA *mob, CHAR_DATA *ch,
		const void *arg1, const void *arg2, int type )   ;
bool	mp_percent_trigger   ( CHAR_DATA *mob, CHAR_DATA *ch, 				
		const void *arg1, const void *arg2, int type )   ;
void	mp_bribe_trigger    ( CHAR_DATA *mob, CHAR_DATA *ch, int amount )   ;
bool	mp_exit_trigger     ( CHAR_DATA *ch, int dir )   ;
bool	rprog_exit_trigger     ( CHAR_DATA *ch, int dir )   ;
bool	oprog_exit_trigger     ( OBJ_DATA *ch, int dir )   ;
void	mp_give_trigger     ( CHAR_DATA *mob, CHAR_DATA *ch, OBJ_DATA *obj )   ;
void 	mp_greet_trigger    ( CHAR_DATA *ch )   ;
void	mp_hprct_trigger    ( CHAR_DATA *mob, CHAR_DATA *ch )   ;
MEM_DATA *get_mem_data        ( CHAR_DATA *ch, CHAR_DATA *target )   ;
void 	mob_remember        ( CHAR_DATA *ch, CHAR_DATA *target, int recation)  ;
void 	mem_fade        ( CHAR_DATA *ch)  ;

  
void	mob_interpret	  ( CHAR_DATA *ch, char *argument )   ;
void    hunt_victim       ( CHAR_DATA *ch )  ;


 
void	string_edit	  ( CHAR_DATA *ch, char **pString )   ;
void    string_append     ( CHAR_DATA *ch, char **pString )   ;
char *	string_replace	  ( char * orig, char * old, char * new )   ;
void    string_add        ( CHAR_DATA *ch, char *argument )   ;
char *  format_string     ( char *oldstring   )   ;
char *  first_arg         ( char *argument, char *arg_first, bool fCase )   ;
char *	string_unpad	  ( char * argument )   ;
char *	string_proper	  ( char * argument )   ;

 
bool	run_olc_editor	  ( DESCRIPTOR_DATA *d )   ;
char	*olc_ed_name	  ( CHAR_DATA *ch )   ;
char	*olc_ed_vnum	  ( CHAR_DATA *ch )   ;

 
void    copyover_recover   ( void )  ;
bool    fCopyOver;
void    do_ispell         ( CHAR_DATA *ch, char *argument)   ;
void    ispell_string     ( CHAR_DATA *ch )   ;




 
int	race_lookup	  ( const char *name)   ;
int	item_lookup	  ( const char *name)   ;
int	liq_lookup	  ( const char *name)   ;

 
void alloc_dhost   ( DESCRIPTOR_DATA *d, const char *host)   ;
void free_host   ( DESCRIPTOR_DATA *d )   ;

 
bool  	        check_has_foci    ( CHAR_DATA *ch, int Sphere_num, int Sphere_Lev)   ;
SPHERE_DATA     *sphere_free;
int gain_paradox   ( CHAR_DATA *ch )  ;

 
void   update_wwf         ( void )   ;
char *get_tribe_name      ( int flags )   ;
int  get_max_rage         ( CHAR_DATA *ch )   ;
void chbreed_form		  ( CHAR_DATA *ch, char *argument)   ;
sh_int get_renown		  ( CHAR_DATA *ch )   ;
void shape_shift        ( CHAR_DATA *ch, int change)  ;

 
void decap_note        ( CHAR_DATA *ch, CHAR_DATA *victim, int Decap_Type, int Decap_OutCome)   ;









 



 





 










 


extern	char *	const	dir_name        [];
extern	const	sh_int	rev_dir         [];           
extern	const	struct	spec_type	spec_table	[];

 


extern		AREA_DATA *		area_first;
extern		AREA_DATA *		area_last;
extern		SHOP_DATA *		shop_last;

extern		int			top_affect;
extern		int			top_area;
extern		int			top_ed;
extern		int			top_exit;
extern		int			top_help;
extern		int			top_mob_index;
extern		int			top_mprog_index;
extern		int			top_obj_index;
extern		int			top_reset;
extern		int			top_room;
extern		int			top_shop;

extern		int			top_vnum_mob;
extern		int			top_vnum_obj;
extern		int			top_vnum_room;

extern		char			str_empty       [1];

extern		MOB_INDEX_DATA *	mob_index_hash  [1024 ];
extern		OBJ_INDEX_DATA *	obj_index_hash  [1024 ];
extern		ROOM_INDEX_DATA *	room_index_hash [1024 ];


 


 


 

 





 
struct mem_data
{
    MEM_DATA 	*next;
    bool	valid;
    long	id; 	
    int 	reaction;
    time_t 	when;
};
void 	check_string  ( void *pMem, size_t sMem )  ;
int		logf( const char *format, ... );
			 

int		chprintf( CHAR_DATA* ch, const char *format, ... );
			 

int		strswitch( const char* arg, ... );
			 
			 
			 
			 
			 
			 
			 

void	vinterpret( CHAR_DATA *ch, char *argument, ... );
			 
			 
			 
			 
			 

extern WEATHER_DATA		weather_info[11 ];
extern  const   struct  item_type	item_table	[];
extern	const	struct	wiznet_type	wiznet_table	[];


























GMemChunk *obj_mem_chunk;
GMemChunk *char_data_mem_chunk;
GMemChunk *descriptor_mem_chunk;
GMemChunk *affect_mem_chunk;
GMemChunk *sphere_mem_chunk;
GMemChunk *extra_desc_mem_chunk;
GMemChunk *pcdata_mem_chunk;
GMemChunk *MobID_mem_chunk;
GMemChunk *ObjID_mem_chunk;
GMemChunk *RoomID_mem_chunk;
GMemChunk *AreaID_mem_chunk;
GMemChunk *HelpID_mem_chunk;

GStringChunk *LurfStringChunk;
# 57 "comm.c" 2

# 1 "../include/tables.h" 1
 
















 









struct ghostaffect_type
{
	char *name;
	int  true_flag;
	int  ghost_flag;
};


struct plane_types
{
	char *name;
	int  plane;
};

struct damage_type
{
    char *attack1;
    char *attack2;
    int  DAM_TYPE;
};

struct renown_rank_type
{
	sh_int glory;
	sh_int honor;
	sh_int wisdom;
};

struct trait_type
{
	char *name;
	int  trait_flag;
	int  cp_cost;
	bool show_player;
	int  trait_set;
};

struct cset_powers_type
{
	char	*power_name;
	int		power_value;
	int		power_class;
};

struct commands_type
{
	int		set_type; 	 
	sh_int	set_num;  	 
	sh_int	gift_type; 	 
	char  * name;	  	 
	char  * command;     
    int     pool_cost;   
    int     wait_time;  
    int     command_type; 
    POWER_FUN * power_fun;  
};

struct sect_type
{
	int		number;
	char *	pretty_name;
	int     spc_bit;
	char *  color;
    char *  alias;
	 
};

struct iclan_type
{
	int		number;
	char *	pretty_name;
	int     sect;
	char *  color;
	int		class;
	 
};

struct rent_type
{
	int	obj_vnum;
	char * 	obj_name;
	int	exp_cost;
	int	qp_cost;
};

struct gifts_type
{
	char * first_name;
	int    first_mud_name;
	char * second_name;
	int    second_mud_name;
	char * third_name;
	int    third_mud_name;
};

struct haunt_type
{
	char * haunt;
};

struct mage_spell_type
{
	char * spell_name;
	char * on_msg;
	char * off_msg;
};

struct mage_sphere_type
{
	char * sphere_name;
	int    sphere_sphere;
};

struct dumb_shit_type
{
	char * command;
};

struct msp_type
{
	char * msp_string;
	char * msp_server;
	char * msp_dirinfo;
};

struct flag_type
{
	char *name;
	int bit;
	bool settable;
};

struct clan_type
{
	char 	*name;
	char 	*who_name;
	sh_int 	hall;
	bool	independent;  
};

struct position_type
{
	char *name;
	char *short_name;
};

struct sex_type
{
	char *name;
};

struct size_type
{
	char *name;
};

struct	bit_type
{
	const	struct	flag_type *	table;
	char *				help;
};

 
extern  const   struct  cset_powers_type cset_powers_list[];
extern	const	struct	position_type	position_table[];
extern	const	struct	sex_type	sex_table[];
extern	const	struct	size_type	size_table[];

extern  const   struct  dumb_shit_type  dumb_shit[];
extern  const   struct  mage_spell_type mage_affect_table[];
extern	const	struct	mage_sphere_type mage_sphere_table[];
extern	const	struct	haunt_type 	haunt_table[];
extern	const	struct	haunt_type 	stance_msg_table[];
extern	const	struct	haunt_type 	remember_table[];
extern	const	struct	haunt_type 	disc_table[];

 
extern	const	struct	msp_type	msp_midi_table[];
extern	const	struct	msp_type	msp_scream_table[];
extern	const	struct	msp_type	msp_general_table[];

 
extern	const	struct	flag_type	act_flags[];
extern	const	struct	flag_type	plr_flags[];
extern	const	struct	flag_type	affect_flags[];
extern	const	struct	flag_type	off_flags[];
extern	const	struct	flag_type	imm_flags[];
extern	const	struct	flag_type	form_flags[];
extern	const	struct	flag_type	part_flags[];
extern	const	struct	flag_type	comm_flags[];
extern	const	struct	flag_type	mob_fight_flags[];
extern	const	struct	flag_type	extra_flags[];
extern	const	struct	flag_type	wear_flags[];
extern	const	struct	flag_type	weapon_flags[];
extern	const	struct	flag_type	container_flags[];
extern	const	struct	flag_type	portal_flags[];
extern	const	struct	flag_type	room_flags[];
extern	const	struct	flag_type	exit_flags[];
extern  const	struct  flag_type	mprog_flags[];
extern  const	struct  flag_type	mprog_obj_flags[];
extern  const	struct  flag_type	mprog_room_flags[];
extern	const	struct	flag_type	area_flags[];
extern	const	struct	flag_type	sector_flags[];
extern	const	struct	flag_type	door_resets[];
extern	const	struct	flag_type	wear_loc_strings[];
extern	const	struct	flag_type	wear_loc_flags[];
extern	const	struct	flag_type	res_flags[];
extern	const	struct	flag_type	imm_flags[];
extern	const	struct	flag_type	vuln_flags[];
extern	const	struct	flag_type	type_flags[];
extern	const	struct	flag_type	apply_flags[];
extern	const	struct	flag_type	sex_flags[];
extern	const	struct	flag_type	furniture_flags[];
extern	const	struct	flag_type	weapon_class[];
extern	const	struct	flag_type	apply_types[];
extern	const	struct	flag_type	weapon_type2[];
extern	const	struct	flag_type	apply_types[];
extern	const	struct	flag_type	size_flags[];
extern	const	struct	flag_type	position_flags[];
extern	const	struct	flag_type	ac_type[];
extern	const	struct	flag_type	spc_flags[];
extern	const	struct	bit_type	bitvector_type[];
extern  const	struct  flag_type	mprog_flags[];
extern 	const	struct 	flag_type	attack_table[];
extern 	const	struct 	flag_type	mob_con_flags[];
 



extern  const   struct  sect_type	sect_table[];
extern  const   struct  iclan_type	iclan_table[];
extern 	const 	struct  rent_type	rent_table[];
extern 	const 	struct  trait_type	trait_table[];

extern  const	struct 	commands_type	hunter_cmds[];
extern  const	struct 	commands_type	mage_cmds[];
extern	const	struct	commands_type	vamp_cmds1[];
extern	const	struct	commands_type	vamp_cmds2[];
extern	const	struct	commands_type	wwf_tot_cmds[];
extern	const	struct	commands_type	wwf_gift_cmds[];
extern  const   struct  renown_rank_type ragabash_table[];
extern  const   struct  renown_rank_type theurge_table[];
extern  const   struct  renown_rank_type philodox_table[];
extern  const   struct  renown_rank_type galliard_table[];
extern  const   struct  renown_rank_type ahroun_table[];
extern  const   struct  damage_type damage_table[];
extern  const   struct  haunt_type  	tribe_table     [];
extern  const   struct  haunt_type  	breed_table     [];
extern  const   struct  haunt_type  	auspice_table     [];


extern  const   struct  plane_types  	plane_table     [];
extern  const   struct  ghostaffect_type ghostaffect_table[];


# 58 "comm.c" 2

# 1 "../include/interp.h" 1
 















 



DO_FUN      do_chomp	       ;
DO_FUN      do_cset		       ;
DO_FUN      do_planewalk	   ;
DO_FUN      do_wraith	       ;
DO_FUN      do_killme	       ;
DO_FUN      do_anon_desc       ;
DO_FUN     	do_hunter          ;
DO_FUN     	do_penalty_renown  ;
DO_FUN     	do_sidestep        ;
DO_FUN     	do_imm_stake       ;
DO_FUN     	do_slots           ;
DO_FUN     	do_learndisc       ;
DO_FUN     	do_high_dice       ;
DO_FUN     	do_lflame          ;
DO_FUN     	do_spwrath         ;
DO_FUN     	do_mindblock       ;
DO_FUN     	do_lunaavenger     ;
DO_FUN     	do_fbite           ;
DO_FUN     	do_bsong           ;
DO_FUN     	do_gift_of_the_spriggian   ;
DO_FUN     	do_howlban         ;
DO_FUN     	do_brage           ;
DO_FUN     	do_wtalon          ;
DO_FUN     	do_gorgon          ;
DO_FUN     	do_pet             ;
DO_FUN     	do_dissolve        ;
DO_FUN     	do_petdrink        ;
DO_FUN     	do_petfeed         ;
DO_FUN     	do_learn_gift      ;
DO_FUN     	do_pettrain        ;
DO_FUN     	do_petscore        ;
DO_FUN     	do_makepet         ;
DO_FUN     	do_checkld         ;
DO_FUN     	do_pbackup         ;
DO_FUN     	do_mage_sspirit    ;
DO_FUN     	do_callspirits     ;
DO_FUN     	do_confusemind     ;
DO_FUN     	do_squarecircle    ;
DO_FUN     	do_mregen		   ;
DO_FUN     	do_darksight	   ;
DO_FUN     	do_falsepride	   ;
DO_FUN     	do_taintmind	   ;
DO_FUN     	do_diablerize	   ;
DO_FUN     	do_entrancement	   ;
DO_FUN     	do_spit			   ;
DO_FUN     	do_bonecraft	   ;
DO_FUN     	do_changeling	   ;
DO_FUN     	do_hice			   ;
DO_FUN     	do_safe_room	   ;
DO_FUN     	chbreeed_form	   ;
DO_FUN     	do_perm_renown	   ;
DO_FUN     	do_give_renown	   ;
DO_FUN     	do_trait 		   ;
DO_FUN     	do_ftouch		   ;
DO_FUN     	do_autoprotect	   ;
DO_FUN     	do_hand			   ;
DO_FUN     	do_loyalty		   ;
DO_FUN     	do_wiznet		   ;
DO_FUN     	do_bad_name		   ;
DO_FUN     	do_list_oowners    ;
DO_FUN     	do_mxpecho 		   ;
DO_FUN     	do_bash			   ;
DO_FUN     	do_rollover		   ;
DO_FUN     	do_callduty		   ;
DO_FUN     	do_spburrow		   ;

DO_FUN     	do_conditioning	   ;
DO_FUN     	do_pigeon	   ;
DO_FUN     	do_beckon	   ;
DO_FUN     	do_serenity	   ;
DO_FUN     	do_sharespirit     ;
DO_FUN     	do_unveil	   ;
DO_FUN     	do_mirrorimage     ;
DO_FUN     	do_formillusion    ;
DO_FUN     	do_cloneobject     ;
DO_FUN     	do_rename	   ;
DO_FUN     	do_control	   ;
DO_FUN     	do_guardian	   ;
DO_FUN     	do_fear            ;
DO_FUN     	do_portal	   ;
DO_FUN     	do_soultwist	   ;
DO_FUN     	do_curse           ;
DO_FUN     	do_scream	   ;
DO_FUN     	do_beastwithin	   ;
DO_FUN     	do_mud_config	  ;

DO_FUN     	do_flag_rp	  ;
DO_FUN     	do_accept	  ;
DO_FUN     	do_powers	  ;
DO_FUN     	do_list_skills	  ;
DO_FUN     	do_check_string	  ;
DO_FUN     	do_agony	  ;
DO_FUN     	do_fleshcraft	  ;
DO_FUN     	do_zuloform	  ;
DO_FUN     	do_breath	  ;
DO_FUN     	do_marble	  ;
DO_FUN     	do_earthmeld	  ;
DO_FUN     	do_disease	  ;
DO_FUN     	do_activate	  ;
DO_FUN     	do_affects 	  ;
DO_FUN     	do_playwave 	  ;
DO_FUN     	do_alignment	  ;
DO_FUN      do_alia           ;
DO_FUN      do_alias          ;
DO_FUN      do_spiralbow      ;
DO_FUN      do_unalias        ;
DO_FUN      do_prefi          ;
DO_FUN      do_prefix         ;
DO_FUN     	do_allow	  ;
DO_FUN     	do_ignore	  ;
DO_FUN     	do_vlist	  ;
DO_FUN     	do_anarch	  ;
DO_FUN     	do_ansi		  ;
DO_FUN     	do_answer	  ;
DO_FUN     	do_antitribu  ;
DO_FUN     	do_showfight  ;
DO_FUN     	do_areas	  ;
DO_FUN     	do_artifact	  ;
DO_FUN     	do_at		  ;
DO_FUN     	do_auto    	  ;
DO_FUN     	do_autodamage     ;
DO_FUN     	do_autoexit	  ;
DO_FUN     	do_autoloot	  ;
DO_FUN     	do_autosac	  ;
DO_FUN     	do_autosave	  ;
DO_FUN     	do_autostance     ;
DO_FUN     	do_avatar         ;
DO_FUN     	do_backstab	  ;
DO_FUN     	do_bamfin	  ;
DO_FUN     	do_bamfout	  ;
DO_FUN     	do_ban		  ;
DO_FUN     	do_beastlike	  ;
DO_FUN     	do_berserk	  ;
DO_FUN     	do_bind		  ;
DO_FUN     	do_birth	  ;
DO_FUN     	do_bite		  ;
DO_FUN     	do_blank	  ;
DO_FUN     	do_blindfold	  ;
DO_FUN     	do_bloodline	  ;
DO_FUN     	do_brandish	  ;
DO_FUN     	do_breakup	  ;
DO_FUN     	do_brief	  ;
DO_FUN     	do_bug		  ;
DO_FUN     	do_essence	  ;
DO_FUN     	do_buy		  ;
DO_FUN     	do_call		  ;
DO_FUN     	do_calm		  ;
DO_FUN     	do_cast		  ;
DO_FUN     	do_change	  ;
DO_FUN     	do_changelight	  ;
DO_FUN     	do_channels	  ;
DO_FUN     	do_chat	  ;
DO_FUN     	do_fvlist	  ;
DO_FUN     	do_cgossip        ;
DO_FUN     	do_claim	  ;
DO_FUN     	do_clandisc	  ;
DO_FUN     	do_show_clan_info  ;
DO_FUN     	do_silent         ;
DO_FUN     	do_weaken         ;
DO_FUN     	do_clanname	  ;
DO_FUN     	do_claw		  ;
DO_FUN     	do_claws	  ;
DO_FUN     	do_nocturn	  ;
DO_FUN     	do_ooc 	  ;
DO_FUN     	do_ahriman	  ;
DO_FUN     	do_abyss	  ;
DO_FUN     	do_close	  ;
DO_FUN     	do_command	  ;
DO_FUN     	do_commands	  ;
DO_FUN     	do_compare	  ;
DO_FUN     	do_complete	  ;
DO_FUN     	do_config	  ;
DO_FUN     	do_consent	  ;
DO_FUN     	do_consider	  ;
DO_FUN     	do_cprompt	  ;
DO_FUN     	do_crack	  ;
DO_FUN     	do_create	  ;
DO_FUN     	do_credits	  ;
DO_FUN     	do_darkheart	  ;
DO_FUN     	do_decapitate	  ;
DO_FUN     	do_delet	  ;
DO_FUN     	do_delete         ;
DO_FUN     	do_deny		  ;
DO_FUN     	do_description	  ;
DO_FUN     	do_diagnose	  ;
DO_FUN     	do_dismount	  ;
DO_FUN     	do_disarm	  ;
DO_FUN     	do_disconnect	  ;
DO_FUN     	do_divorce	  ;
DO_FUN     	do_notag          ;
DO_FUN     	do_tag            ;
DO_FUN     	do_donate	  ;
DO_FUN     	do_down		  ;
DO_FUN     	do_draw		  ;
DO_FUN     	do_drink	  ;
DO_FUN     	do_drop		  ;
DO_FUN     	do_ntrust	  ;
DO_FUN     	do_map		  ;
DO_FUN     	do_offer	  ;
DO_FUN     	do_offersoul	  ;
DO_FUN     	do_omni		  ;
DO_FUN     	do_grant	  ;
DO_FUN     	do_east		  ;
DO_FUN     	do_eat		  ;
DO_FUN     	do_echo		  ;
DO_FUN     	do_empty	  ;
DO_FUN     	do_escape	  ;
DO_FUN     	do_email	  ;
DO_FUN     	do_emote	  ;
DO_FUN     	do_enter	  ;
DO_FUN     	do_equipment	  ;
DO_FUN     	do_evileye	  ;
DO_FUN     	do_examine	  ;
DO_FUN     	do_exits	  ;
DO_FUN     	do_familiar	  ;
DO_FUN     	do_fangs	  ;
DO_FUN     	do_favour	  ;
DO_FUN     	do_fcommand	  ;
DO_FUN     	do_murmur	  ;
DO_FUN     	do_feed		  ;
DO_FUN     	do_fightstyle	  ;
DO_FUN     	do_fileupdate	  ;
DO_FUN     	do_fill		  ;
DO_FUN     	do_finger	  ;
DO_FUN     	do_flee		  ;
DO_FUN     	do_flex		  ;
DO_FUN     	do_follow	  ;
DO_FUN     	do_force	  ;
DO_FUN     	do_forceauto	  ;
DO_FUN     	do_freeze	  ;
DO_FUN     	do_gag		  ;
DO_FUN     	do_garou	  ;
DO_FUN     	do_get		  ;
DO_FUN     	do_ghoul	  ;
DO_FUN     	do_gift		  ;
DO_FUN     	do_gifts	  ;
DO_FUN     	do_give		  ;
DO_FUN     	do_godless	  ;
DO_FUN     	do_goto		  ;
DO_FUN     	do_group	  ;
DO_FUN     	do_gtell	  ;
DO_FUN     	do_help		  ;
DO_FUN     	do_hide		  ;
DO_FUN     	do_holylight	  ;
DO_FUN     	do_home		  ;
DO_FUN     	do_howl		  ;
DO_FUN     	do_huh		  ;
DO_FUN     	do_humanform	  ;
DO_FUN     	do_humanity	  ;
DO_FUN     	do_hunt		  ;
DO_FUN     	do_hurl		  ;
DO_FUN     	do_immune	  ;
DO_FUN     	do_immtalk	  ;
DO_FUN      do_incog          ;
DO_FUN     	do_inconnu	  ;
DO_FUN     	do_induct 	  ;
DO_FUN     	do_info		  ;
DO_FUN     	do_mspoff	  ;
DO_FUN     	do_introduce	  ;
DO_FUN     	do_outfit	  ;
DO_FUN     	do_inventory	  ;
DO_FUN     	do_invis	  ;
DO_FUN     	do_kick		  ;
DO_FUN     	do_kill		  ;
DO_FUN     	do_killperson	  ;
DO_FUN     	do_list		  ;
DO_FUN     	do_locate	  ;
DO_FUN     	do_lock		  ;
DO_FUN     	do_log		  ;
DO_FUN     	do_logout         ;
DO_FUN     	do_look		  ;
DO_FUN     	do_majesty	  ;
DO_FUN     	do_marry	  ;
DO_FUN     	do_mask		  ;
DO_FUN     	do_meditate	  ;
DO_FUN     	do_memory	  ;
DO_FUN     	do_mfind	  ;
DO_FUN     	do_mload	  ;
DO_FUN     	do_mount	  ;
DO_FUN     	do_morph	  ;
DO_FUN     	do_mortal	  ;
DO_FUN     	do_mortalvamp	  ;
DO_FUN     	do_mset		  ;
DO_FUN     	do_mstat	  ;
DO_FUN     	do_mwhere	  ;
DO_FUN     	do_music	  ;
DO_FUN     	do_nightsight	  ;
DO_FUN     	do_noemote	  ;
DO_FUN     	do_north	  ;
DO_FUN     	do_note		  ;
DO_FUN     	do_notell	  ;
DO_FUN     	do_oclone	  ;
DO_FUN     	do_ofind	  ;
DO_FUN     	do_oload	  ;
DO_FUN     	do_open		  ;
DO_FUN     	do_order	  ;
DO_FUN     	do_oreturn	  ;
DO_FUN     	do_oset		  ;
DO_FUN     	do_ostat	  ;
DO_FUN     	do_oswitch	  ;
DO_FUN     	do_otransfer	  ;
DO_FUN     	do_pact		  ;
DO_FUN     	do_password	  ;
DO_FUN     	do_peace	  ;
DO_FUN     	do_permban	  ;
DO_FUN     	do_pick		  ;
DO_FUN     	do_pload	  ;
DO_FUN     	do_poison	  ;
DO_FUN     	do_practice	  ;
DO_FUN     	do_pray		  ;
DO_FUN     	do_press	  ;
DO_FUN     	do_preturn	  ;
DO_FUN     	do_prompt	  ;
DO_FUN     	do_propose	  ;
DO_FUN     	do_pset		  ;
DO_FUN     	do_pull		  ;
DO_FUN     	do_punch	  ;
DO_FUN     	do_stomp	  ;
DO_FUN     	do_purge	  ;
DO_FUN     	do_put		  ;
DO_FUN     	do_qmake	  ;
DO_FUN     	do_quaff	  ;
DO_FUN     	do_qset		  ;
DO_FUN     	do_qstat	  ;
DO_FUN     	do_qtrust	  ;
DO_FUN     	do_quest	  ;
DO_FUN     	do_question	  ;
DO_FUN     	do_qui		  ;
DO_FUN     	do_quit		  ;
DO_FUN     	do_rage		  ;
DO_FUN     	do_read		  ;
DO_FUN     	do_copyover	  ;
DO_FUN     	do_unread         ;
DO_FUN     	do_readaura	  ;
DO_FUN     	do_reboo	  ;
DO_FUN     	do_reboot	  ;
DO_FUN     	do_recall	  ;
DO_FUN     	do_recharge	  ;
DO_FUN     	do_recho	  ;
DO_FUN     	do_recite	  ;
DO_FUN     	do_regenerate	  ;
DO_FUN     	do_release	  ;
DO_FUN     	do_reload	  ;
DO_FUN     	do_remove	  ;
DO_FUN     	do_reply	  ;
DO_FUN     	do_report	  ;
DO_FUN     	do_rescue	  ;
DO_FUN     	do_rest		  ;
DO_FUN     	do_restore	  ;
DO_FUN     	do_return	  ;
DO_FUN     	do_rset		  ;
DO_FUN     	do_rstat	  ;
DO_FUN     	do_sacrifice	  ;
DO_FUN     	do_safe		  ;
DO_FUN     	do_save		  ;
DO_FUN     	do_say		  ;
DO_FUN     	do_scan		  ;
DO_FUN     	do_score	  ;
DO_FUN     	do_scry		  ;
DO_FUN     	do_sell		  ;
DO_FUN     	do_serpent	  ;
DO_FUN     	do_shadowplane	  ;
DO_FUN     	do_shadowsight	  ;
DO_FUN     	do_sheath	  ;
DO_FUN     	do_shield	  ;
DO_FUN     	do_shoot	  ;
DO_FUN     	do_shout	  ;
DO_FUN     	do_shutdow	  ;
DO_FUN     	do_shutdown	  ;
DO_FUN     	do_show_artifacts  ;
DO_FUN     	do_side		  ;
DO_FUN     	do_silence	  ;
DO_FUN     	do_sit		  ;
DO_FUN     	do_skill	  ;
DO_FUN     	do_skillall	  ;
DO_FUN     	do_skillz  	  ;
DO_FUN     	do_sla		  ;
DO_FUN     	do_slay		  ;
DO_FUN     	do_sleep	  ;
DO_FUN     	do_slookup	  ;
DO_FUN     	do_speak	  ;
DO_FUN     	do_spc		  ;
DO_FUN     	do_special	  ;
DO_FUN     	do_spell	  ;
DO_FUN     	do_stake	  ;
DO_FUN     	do_stance	  ;
DO_FUN     	do_smother	  ;
DO_FUN     	do_sneak	  ;
DO_FUN     	do_snoop	  ;
DO_FUN     	do_socials	  ;
DO_FUN     	do_south	  ;
DO_FUN     	do_split	  ;
DO_FUN     	do_spy		  ;
DO_FUN     	do_spydirection	  ;
DO_FUN     	do_sset		  ;
DO_FUN     	do_stand	  ;
DO_FUN     	do_steal	  ;
DO_FUN     	do_summon	  ;
DO_FUN     	do_switch	  ;
DO_FUN     	do_teach	  ;
DO_FUN     	do_tear		  ;
DO_FUN     	do_tell		  ;
DO_FUN     	do_throw	  ;
DO_FUN     	do_tie		  ;
DO_FUN     	do_time		  ;
DO_FUN     	do_title	  ;
DO_FUN     	do_token	  ;
DO_FUN     	do_totems	  ;
DO_FUN     	do_track	  ;
DO_FUN     	do_tradition	  ;
DO_FUN     	do_train	  ;
DO_FUN     	do_transfer	  ;
DO_FUN     	do_transport	  ;
DO_FUN     	do_tribe	  ;
DO_FUN     	do_secttalk	  ;
DO_FUN     	do_truesight	  ;
DO_FUN     	do_trust	  ;
DO_FUN     	do_turn		  ;
DO_FUN     	do_twist	  ;
DO_FUN     	do_check	  ;
DO_FUN     	do_typo		  ;
DO_FUN     	do_unload	  ;
DO_FUN     	do_unlock	  ;
DO_FUN     	do_unpolymorph	  ;
DO_FUN     	do_untie	  ;
DO_FUN     	do_unwerewolf	  ;
DO_FUN     	do_up		  ;
DO_FUN     	do_upkeep	  ;
DO_FUN     	do_users	  ;
DO_FUN     	do_newusers	  ;
DO_FUN     	do_value	  ;
DO_FUN     	do_vampire	  ;
DO_FUN     	do_vamptalk	  ;
DO_FUN     	do_hooves	  ;
DO_FUN     	do_magetalk	  ;
DO_FUN     	do_vanish	  ;
DO_FUN     	do_vclan	  ;
DO_FUN     	do_version	  ;
DO_FUN     	do_visible	  ;
DO_FUN     	do_vote	  ;
DO_FUN     	do_voodoo	  ;
DO_FUN     	do_web		  ;
DO_FUN     	do_wake		  ;
DO_FUN     	do_watcher	  ;
DO_FUN     	do_watching	  ;
DO_FUN     	do_wear		  ;
DO_FUN     	do_wearaffect	  ;
DO_FUN     	do_weather	  ;
DO_FUN     	do_werewolf	  ;
DO_FUN     	do_west		  ;
DO_FUN     	do_where	  ;
DO_FUN     	do_whisper	  ;
DO_FUN     	do_who		  ;
DO_FUN     	do_animawalk	  ;
DO_FUN     	do_wimpy	  ;
DO_FUN     	do_wizhelp	  ;
DO_FUN     	do_wizlist	  ;
DO_FUN     	do_wizlock	  ;
DO_FUN     	do_write	  ;
DO_FUN     	do_xemote	  ;
DO_FUN     	do_xsocials	  ;
DO_FUN     	do_yell		  ;
DO_FUN     	do_zap		  ;
DO_FUN      do_olc		  ;
DO_FUN      do_asave	  ;
DO_FUN      do_alist	  ;
DO_FUN      do_resets	  ;
DO_FUN      do_showspecial	  ;
DO_FUN      do_beast	  ;
DO_FUN      do_mirror	  ;
DO_FUN      do_spriggan	  ;
DO_FUN      do_pounce	  ;
DO_FUN      do_burrow	  ;
DO_FUN      do_luna   	  ;
DO_FUN      do_moongate	  ;
DO_FUN      do_sphere	  ;
DO_FUN      do_sphereaffects  ;
DO_FUN      do_entropy_shield  ;
DO_FUN      do_force_shield   ;
DO_FUN      do_mind_shield    ;
DO_FUN      do_life_shield    ;
DO_FUN      do_prime_shield   ;
DO_FUN      do_spirit_shield  ;
DO_FUN      do_mage 	  ;
DO_FUN      do_create_foci    ;
DO_FUN      do_focistat 	  ;
DO_FUN      do_charged_bolt   ;
DO_FUN      do_alter_flow     ;
DO_FUN      do_mana_shield	  ;
DO_FUN      do_heal    	  ;
DO_FUN      do_pathos	  ;
DO_FUN      do_location       ;
DO_FUN      do_travel	  ;
DO_FUN      do_speed_time	  ;
DO_FUN      do_slow_time	  ;
DO_FUN      do_dispel	  ;
DO_FUN      do_rip		  ;
DO_FUN      do_flames	  ;
DO_FUN      do_polymorph	  ;
DO_FUN      do_unmist	  ;
DO_FUN      do_mist	  ;
DO_FUN      do_mob		  ;
DO_FUN      do_mpstat	  ;
DO_FUN      do_mpdump	  ;
DO_FUN      do_counterspell   ;
DO_FUN      do_surrender	  ;
DO_FUN      do_cloak	  ;
DO_FUN      do_nightfall	  ;
DO_FUN      do_gaze		  ;
DO_FUN      do_confuse	  ;
DO_FUN      do_insane	  ;
DO_FUN      do_vsummon	  ;
DO_FUN      do_haunt	  ;
DO_FUN      do_awe		  ;
DO_FUN      do_moonbeam	  ;
DO_FUN      do_cookie	  ;
DO_FUN      do_greet	  ;
DO_FUN      do_meet	          ;
DO_FUN      do_board	  ;
DO_FUN      do_askquest	  ;
DO_FUN      do_penalty	  ;
DO_FUN      do_style	  ;
DO_FUN      do_nature	  ;
DO_FUN      do_demeanor	  ;
DO_FUN      do_for		  ;
DO_FUN      do_clear	  ;
DO_FUN      do_roompose	  ;
DO_FUN      do_autocopy	  ;
DO_FUN      do_mob_hunt	  ;
DO_FUN      do_filet	  ;
DO_FUN      do_chop		  ;
DO_FUN      do_make_fire	  ;
DO_FUN      do_cook		  ;
DO_FUN      do_wash		  ;
DO_FUN      do_garou_status	  ;
DO_FUN      do_shapeshift	  ;
DO_FUN      do_tenebrous	  ;
DO_FUN      do_rent		  ;
DO_FUN      do_icy		  ;
DO_FUN      do_persuasion	  ;
DO_FUN      do_staredown	  ;
DO_FUN      do_witherlimb	  ;
DO_FUN      do_blur		  ;
DO_FUN      do_truefear	  ;
DO_FUN      do_scentbeyond	  ;
DO_FUN      do_disquiet	  ;
DO_FUN      do_aeolus	  ;
DO_FUN      do_porcupine	  ;
DO_FUN      do_obedience	  ;
DO_FUN      do_paralyzing	  ;
DO_FUN      do_clap		  ;
DO_FUN      do_fetishdoll	  ;
DO_FUN      do_invisibility	  ;
DO_FUN      do_wallgranite	  ;
DO_FUN      do_camouflage	  ;
DO_FUN      do_reshape	  ;
DO_FUN      do_teachgift	  ;
DO_FUN      do_halosun	  ;
DO_FUN      do_mother	  ;
DO_FUN      do_bodywrack	  ;
DO_FUN      do_wyld		  ;
DO_FUN      do_dazzle	  ;
DO_FUN      do_tail		  ;
DO_FUN      do_rain		  ;
DO_FUN      do_eclipse	  ;
DO_FUN      do_lightning	  ;
DO_FUN      do_wall		  ;
DO_FUN      do_animal	  ;
DO_FUN      do_fleshbond	  ;
DO_FUN      do_masssummons	  ;
DO_FUN      do_spclaw	  ;
DO_FUN      do_newmem	  ;
DO_FUN      do_tap_caern  ;
DO_FUN      aslan_axe  ;

# 59 "comm.c" 2

# 1 "../include/recycle.h" 1
 
















 









 
extern char str_empty[1];
extern int mobile_count;

 





 




 

BAN_DATA 	*new_ban   (void)   ;
void	free_ban   (BAN_DATA *ban)   ;


 

DESCRIPTOR_DATA 	*new_descriptor   (void)   ; 
void	free_descriptor   (DESCRIPTOR_DATA *d)   ;


 






 

AFFECT_DATA 	*new_affect   (void)   ;
void	free_affect   (AFFECT_DATA *af)   ;


 

SPHERE_DATA 	*new_sphere   (void)   ;
void	free_sphere   (SPHERE_DATA *af)   ;


 

OBJ_DATA 	*new_obj   (void)   ;
void	free_obj   (OBJ_DATA *obj)   ;


 


CHAR_DATA 	*new_char   (void)   ;
void	free_char   (CHAR_DATA *ch)   ;
PC_DATA 	*new_pcdata   (void)   ;
void	free_pcdata   (PC_DATA *pcdata)   ;




 









 

BUFFER	*new_buf   (void)   ;
BUFFER  *new_buf_size   (int size)   ;
void	free_buf   (BUFFER *buffer)   ;
bool	add_buf   (BUFFER *buffer, char *string)   ;
void	clear_buf   (BUFFER *buffer)   ;
char	*buf_string   (BUFFER *buffer)   ;


 

KNOWN_DATA 	*new_known   (void)   ;
void	free_known   (KNOWN_DATA *known)   ;

MPROG_LIST *new_mprog  (void)  ;
MPROG_CODE *new_mpcode  (void)  ;
RESET_DATA *new_reset_data  (void)  ;
EXIT_DATA  *new_exit  (void)  ;
SHOP_DATA  *new_shop  (void)  ;

 

long 	get_pc_id   (void)   ;
long	get_mob_id   (void)   ;
MEM_DATA 	*new_mem_data   (void)   ;
void	free_mem_data   ( MEM_DATA *memory)   ;
MEM_DATA 	*find_memory   (MEM_DATA *memory, long id)   ;

# 60 "comm.c" 2

# 1 "../include/telnet.h" 1
 




 





                           	       
                                       








                                    
                                    

                                    
                                    
                                    

                                    
                                    

                                    
                                    
                                    
                                    

                                    
                                    
                                    
                                    


 




















































enum {
	INACTIVE,
	REQUESTED,
	ACTIVE
};

 


int parse_telnetcommand (DESCRIPTOR_DATA *d);
void init_telnet_optns(DESCRIPTOR_DATA *d);
void send_reply(DESCRIPTOR_DATA *d,unsigned char cmd, unsigned char option);

# 61 "comm.c" 2


# 1 "/usr/include/sys/stat.h" 1 3
 

















 










# 78 "/usr/include/sys/stat.h" 3


# 94 "/usr/include/sys/stat.h" 3


 

# 1 "/usr/include/bits/stat.h" 1 3
 





















 






 





struct stat
  {
    __dev_t st_dev;			 
    unsigned short int __pad1;

    __ino_t st_ino;			 



    __mode_t st_mode;			 
    __nlink_t st_nlink;			 
    __uid_t st_uid;			 
    __gid_t st_gid;			 
    __dev_t st_rdev;			 
    unsigned short int __pad2;

    __off_t st_size;			 



    __blksize_t st_blksize;		 


    __blkcnt_t st_blocks;		 



    __time_t st_atime;			 
    unsigned long int __unused1;
    __time_t st_mtime;			 
    unsigned long int __unused2;
    __time_t st_ctime;			 
    unsigned long int __unused3;

    unsigned long int __unused4;
    unsigned long int __unused5;



  };

# 102 "/usr/include/bits/stat.h" 3


 



 



 








 





 







# 98 "/usr/include/sys/stat.h" 2 3




















 























 










 





 






 











 





 




 









 
extern int stat (__const char *__restrict __file,
		 struct stat *__restrict __buf)  ;

 

extern int fstat (int __fd, struct stat *__buf)  ;
# 217 "/usr/include/sys/stat.h" 3









 

extern int lstat (__const char *__restrict __file,
		  struct stat *__restrict __buf)  ;
# 239 "/usr/include/sys/stat.h" 3







 


extern int chmod (__const char *__file, __mode_t __mode)  ;

 

extern int fchmod (int __fd, __mode_t __mode)  ;



 

extern __mode_t umask (__mode_t __mask)  ;







 
extern int mkdir (__const char *__path, __mode_t __mode)  ;

 



extern int mknod (__const char *__path, __mode_t __mode, __dev_t __dev)
      ;



 
extern int mkfifo (__const char *__path, __mode_t __mode)  ;

 





















 

extern int __fxstat (int __ver, int __fildes, struct stat *__stat_buf)  ;
extern int __xstat (int __ver, __const char *__filename,
		    struct stat *__stat_buf)  ;
extern int __lxstat (int __ver, __const char *__filename,
		     struct stat *__stat_buf)  ;
# 327 "/usr/include/sys/stat.h" 3










extern int __xmknod (int __ver, __const char *__path, __mode_t __mode,
		     __dev_t *__dev)  ;


 

extern __inline__ int stat (__const char *__path,
			    struct stat *__statbuf)  
{
  return __xstat (3  , __path, __statbuf);
}


extern __inline__ int lstat (__const char *__path,
			     struct stat *__statbuf)  
{
  return __lxstat (3  , __path, __statbuf);
}


extern __inline__ int fstat (int __fd, struct stat *__statbuf)  
{
  return __fxstat (3  , __fd, __statbuf);
}


extern __inline__ int mknod (__const char *__path, __mode_t __mode,
			     __dev_t __dev)  
{
  return __xmknod (1  , __path, __mode, &__dev);
}


# 391 "/usr/include/sys/stat.h" 3




 



# 63 "comm.c" 2



# 1 "/usr/include/fcntl.h" 1 3
 

















 








 
 

 

# 1 "/usr/include/bits/fcntl.h" 1 3
 

























 






















 











 


































 


 




 




 














# 134 "/usr/include/bits/fcntl.h" 3


struct flock
  {
    short int l_type;	 
    short int l_whence;	 

    __off_t l_start;	 
    __off_t l_len;	 




    __pid_t l_pid;	 
  };

# 159 "/usr/include/bits/fcntl.h" 3


 









 








# 33 "/usr/include/fcntl.h" 2 3


 






 








 






 

extern int fcntl (int __fd, int __cmd, ...)  ;

 



extern int open (__const char *__file, int __oflag, ...)  ;












 



extern int creat (__const char *__file, __mode_t __mode)  ;














 



 









extern int lockf (int __fd, int __cmd, __off_t __len)  ;













# 163 "/usr/include/fcntl.h" 3


 


# 66 "comm.c" 2

# 1 "/usr/include/netdb.h" 1 3
 

















 








# 1 "/usr/include/netinet/in.h" 1 3
 





















# 1 "/usr/include/stdint.h" 1 3
 

















 








# 1 "/usr/include/bits/wordsize.h" 1 3
 


















# 28 "/usr/include/stdint.h" 2 3


 

 

 
# 46 "/usr/include/stdint.h" 3


 
typedef unsigned char		uint8_t;
typedef unsigned short int	uint16_t;

typedef unsigned int		uint32_t;





__extension__
typedef unsigned long long int	uint64_t;



 

 
typedef signed char		int_least8_t;
typedef short int		int_least16_t;
typedef int			int_least32_t;



__extension__
typedef long long int		int_least64_t;


 
typedef unsigned char		uint_least8_t;
typedef unsigned short int	uint_least16_t;
typedef unsigned int		uint_least32_t;



__extension__
typedef unsigned long long int	uint_least64_t;



 

 
typedef signed char		int_fast8_t;





typedef int			int_fast16_t;
typedef int			int_fast32_t;
__extension__
typedef long long int		int_fast64_t;


 
typedef unsigned char		uint_fast8_t;





typedef unsigned int		uint_fast16_t;
typedef unsigned int		uint_fast32_t;
__extension__
typedef unsigned long long int	uint_fast64_t;



 








typedef int			intptr_t;


typedef unsigned int		uintptr_t;



 




__extension__
typedef long long int		intmax_t;
__extension__
typedef unsigned long long int	uintmax_t;



 











 

 




 





 






 




 





 






 









 










 











 











 

 


 



 

 








 



 






 

 




 






 



 









 









 











# 23 "/usr/include/netinet/in.h" 2 3




 

 
enum
  {
    IPPROTO_IP = 0,	    

    IPPROTO_HOPOPTS = 0,    

    IPPROTO_ICMP = 1,	    

    IPPROTO_IGMP = 2,	    

    IPPROTO_IPIP = 4,	    

    IPPROTO_TCP = 6,	    

    IPPROTO_EGP = 8,	    

    IPPROTO_PUP = 12,	    

    IPPROTO_UDP = 17,	    

    IPPROTO_IDP = 22,	    

    IPPROTO_TP = 29,	    

    IPPROTO_IPV6 = 41,      

    IPPROTO_ROUTING = 43,   

    IPPROTO_FRAGMENT = 44,  

    IPPROTO_RSVP = 46,	    

    IPPROTO_GRE = 47,	    

    IPPROTO_ESP = 50,       

    IPPROTO_AH = 51,        

    IPPROTO_ICMPV6 = 58,    

    IPPROTO_NONE = 59,      

    IPPROTO_DSTOPTS = 60,   

    IPPROTO_MTP = 92,	    

    IPPROTO_ENCAP = 98,	    

    IPPROTO_PIM = 103,	    

    IPPROTO_COMP = 108,	    

    IPPROTO_RAW = 255,	    

    IPPROTO_MAX
  };


 
typedef uint16_t in_port_t;

 
enum
  {
    IPPORT_ECHO = 7,		 
    IPPORT_DISCARD = 9,		 
    IPPORT_SYSTAT = 11,		 
    IPPORT_DAYTIME = 13,	 
    IPPORT_NETSTAT = 15,	 
    IPPORT_FTP = 21,		 
    IPPORT_TELNET = 23,		 
    IPPORT_SMTP = 25,		 
    IPPORT_TIMESERVER = 37,	 
    IPPORT_NAMESERVER = 42,	 
    IPPORT_WHOIS = 43,		 
    IPPORT_MTP = 57,

    IPPORT_TFTP = 69,		 
    IPPORT_RJE = 77,
    IPPORT_FINGER = 79,		 
    IPPORT_TTYLINK = 87,
    IPPORT_SUPDUP = 95,		 


    IPPORT_EXECSERVER = 512,	 
    IPPORT_LOGINSERVER = 513,	 
    IPPORT_CMDSERVER = 514,
    IPPORT_EFSSERVER = 520,

     
    IPPORT_BIFFUDP = 512,
    IPPORT_WHOSERVER = 513,
    IPPORT_ROUTESERVER = 520,

     
    IPPORT_RESERVED = 1024,

     
    IPPORT_USERRESERVED = 5000
  };


 
typedef uint32_t in_addr_t;
struct in_addr
  {
    in_addr_t s_addr;
  };


 



























 

 

 


 

 




 






 
struct in6_addr
  {
    union
      {
	uint8_t	u6_addr8[16];
	uint16_t u6_addr16[8];
	uint32_t u6_addr32[4];
      } in6_u;



  };

extern const struct in6_addr in6addr_any;         
extern const struct in6_addr in6addr_loopback;    






 
# 1 "/usr/include/bits/socket.h" 1 3
 



























# 1 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 1 3






 


# 19 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3



 


 





 


# 61 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 





 


















 





 

 

# 131 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 


# 188 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3





 




 

# 271 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


# 283 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 

# 317 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3




 





















# 29 "/usr/include/bits/socket.h" 2 3


# 1 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/limits.h" 1 3
 


 

# 114 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/limits.h" 3







# 31 "/usr/include/bits/socket.h" 2 3



 

typedef __socklen_t socklen_t;



 
enum __socket_type
{
  SOCK_STREAM = 1,		 


  SOCK_DGRAM = 2,		 


  SOCK_RAW = 3,			 

  SOCK_RDM = 4,			 

  SOCK_SEQPACKET = 5,		 


  SOCK_PACKET = 10		 



};

 































 































 











 


 
# 1 "/usr/include/bits/sockaddr.h" 1 3
 


















 







 
typedef unsigned short int sa_family_t;

 









# 142 "/usr/include/bits/socket.h" 2 3


 
struct sockaddr
  {
    sa_family_t  sa_family ;	 
    char sa_data[14];		 
  };


 









struct sockaddr_storage
  {
    sa_family_t  ss_family ;	 
    __uint32_t  __ss_align;	 
    char __ss_padding[(128  - (2 * sizeof (__uint32_t ))) ];
  };


 
enum
  {
    MSG_OOB		= 0x01,	 

    MSG_PEEK		= 0x02,	 

    MSG_DONTROUTE	= 0x04,	 






    MSG_CTRUNC		= 0x08,	 

    MSG_PROXY		= 0x10,	 

    MSG_TRUNC		= 0x20,

    MSG_DONTWAIT	= 0x40,  

    MSG_EOR		= 0x80,  

    MSG_WAITALL		= 0x100,  

    MSG_FIN		= 0x200,

    MSG_SYN		= 0x400,

    MSG_CONFIRM		= 0x800,  

    MSG_RST		= 0x1000,

    MSG_ERRQUEUE	= 0x2000,  

    MSG_NOSIGNAL	= 0x4000,  

    MSG_MORE		= 0x8000   

  };


 

struct msghdr
  {
    void *msg_name;		 
    socklen_t msg_namelen;	 

    struct iovec *msg_iov;	 
    int msg_iovlen;		 

    void *msg_control;		 
    socklen_t msg_controllen;	 

    int msg_flags;		 
  };

 
struct cmsghdr
  {
    size_t cmsg_len;		 

    int cmsg_level;		 
    int cmsg_type;		 

    __extension__ unsigned char __cmsg_data [0] ;  

  };

 















extern struct cmsghdr *__cmsg_nxthdr (struct msghdr *__mhdr,
				      struct cmsghdr *__cmsg)  ;




extern __inline  struct cmsghdr *
__cmsg_nxthdr (struct msghdr *__mhdr, struct cmsghdr *__cmsg)  
{
  if ((size_t) __cmsg->cmsg_len < sizeof (struct cmsghdr))
     
    return 0;

  __cmsg = (struct cmsghdr *) ((unsigned char *) __cmsg
			       + ((( __cmsg->cmsg_len ) + sizeof (size_t) - 1) & (size_t) ~(sizeof (size_t) - 1)) );
  if ((unsigned char *) (__cmsg + 1) > ((unsigned char *) __mhdr->msg_control
					+ __mhdr->msg_controllen)
      || ((unsigned char *) __cmsg + ((( __cmsg->cmsg_len ) + sizeof (size_t) - 1) & (size_t) ~(sizeof (size_t) - 1)) 
	  > ((unsigned char *) __mhdr->msg_control + __mhdr->msg_controllen)))
     
    return 0;
  return __cmsg;
}


 

enum
  {
    SCM_RIGHTS = 0x01,		 


    SCM_CREDENTIALS = 0x02,      


    __SCM_CONNECT = 0x03	 
  };

 

struct ucred
{
  pid_t pid;			 
  uid_t uid;			 
  gid_t gid;			 
};

 
# 1 "/usr/include/asm/socket.h" 1 3



# 1 "/usr/include/asm/sockios.h" 1 3



 








# 4 "/usr/include/asm/socket.h" 2 3


 
















 







 






 









 
# 62 "/usr/include/asm/socket.h" 3



# 305 "/usr/include/bits/socket.h" 2 3



 
struct linger
  {
    int l_onoff;		 
    int l_linger;		 
  };


# 212 "/usr/include/netinet/in.h" 2 3



 
struct sockaddr_in
  {
    sa_family_t  sin_family ;
    in_port_t sin_port;			 
    struct in_addr sin_addr;		 

     
    unsigned char sin_zero[sizeof (struct sockaddr) -
			   (sizeof (unsigned short int))  -
			   sizeof (in_port_t) -
			   sizeof (struct in_addr)];
  };

 
struct sockaddr_in6
  {
    sa_family_t  sin6_family ;
    in_port_t sin6_port;	 
    uint32_t sin6_flowinfo;	 
    struct in6_addr sin6_addr;	 
    uint32_t sin6_scope_id;	 
  };

 
struct ipv6_mreq
  {
     
    struct in6_addr ipv6mr_multiaddr;

     
    unsigned int ipv6mr_interface;
  };

 
# 1 "/usr/include/bits/in.h" 1 3
 

















 





 






















 


 




 






 


struct ip_opts
  {
    struct in_addr ip_dst;	 
    char ip_opts[40];		 
  };

 
struct ip_mreq
  {
    struct in_addr imr_multiaddr;	 
    struct in_addr imr_interface;	 
  };

 
struct ip_mreqn
  {
    struct in_addr imr_multiaddr;	 
    struct in_addr imr_address;		 
    int	imr_ifindex;			 
  };

 
struct in_pktinfo
  {
    int ipi_ifindex;			 
    struct in_addr ipi_spec_dst;	 
    struct in_addr ipi_addr;		 
  };

 

























 






 




 



 




# 250 "/usr/include/netinet/in.h" 2 3


 






extern uint32_t ntohl (uint32_t __netlong)   __attribute__ ((__const__));
extern uint16_t ntohs (uint16_t __netshort)
       __attribute__ ((__const__));
extern uint32_t htonl (uint32_t __hostlong)
       __attribute__ ((__const__));
extern uint16_t htons (uint16_t __hostshort)
       __attribute__ ((__const__));



 
# 1 "/usr/include/bits/byteswap.h" 1 3
 

























 





# 43 "/usr/include/bits/byteswap.h" 3






 





 



# 71 "/usr/include/bits/byteswap.h" 3
# 82 "/usr/include/bits/byteswap.h" 3







 

# 99 "/usr/include/bits/byteswap.h" 3


# 113 "/usr/include/bits/byteswap.h" 3



# 270 "/usr/include/netinet/in.h" 2 3



 


























































 
extern int bindresvport (int __sockfd, struct sockaddr_in *__sock_in)  ;

 
extern int bindresvport6 (int __sockfd, struct sockaddr_in6 *__sock_in)
      ;






















 
struct in6_pktinfo
  {
    struct in6_addr	ipi6_addr;     
    unsigned int	ipi6_ifindex;  
  };

 


# 28 "/usr/include/netdb.h" 2 3



 

# 1 "/usr/include/rpc/netdb.h" 1 3
 
 



























 

 









# 1 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 1 3






 


# 19 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3



 


 





 


# 61 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 





 


















 





 

 

# 131 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 


# 188 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3





 




 

# 271 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


# 283 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 

# 317 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3




 





















# 42 "/usr/include/rpc/netdb.h" 2 3


 

struct rpcent
{
  char *r_name;		 
  char **r_aliases;	 
  int r_number;		 
};

extern void setrpcent (int __stayopen)  ;
extern void endrpcent (void)  ;
extern struct rpcent *getrpcbyname (__const char *__name)  ;
extern struct rpcent *getrpcbynumber (int __number)  ;
extern struct rpcent *getrpcent (void)  ;


extern int getrpcbyname_r (__const char *__name, struct rpcent *__result_buf,
			   char *__buffer, size_t __buflen,
			   struct rpcent **__result)  ;

extern int getrpcbynumber_r (int __number, struct rpcent *__result_buf,
			     char *__buffer, size_t __buflen,
			     struct rpcent **__result)  ;

extern int getrpcent_r (struct rpcent *__result_buf, char *__buffer,
			size_t __buflen, struct rpcent **__result)  ;


 


# 33 "/usr/include/netdb.h" 2 3










# 1 "/usr/include/bits/netdb.h" 1 3
 






















 


struct netent
{
  char *n_name;			 
  char **n_aliases;		 
  int n_addrtype;		 
  uint32_t n_net;		 
};
# 43 "/usr/include/netdb.h" 2 3


 








 

 
extern int h_errno;

 
extern int *__h_errno_location (void)   __attribute__ ((__const__));

# 72 "/usr/include/netdb.h" 3




 




 





















 

extern void herror (__const char *__str)  ;

 
extern __const char *hstrerror (int __err_num)  ;



 
struct hostent
{
  char *h_name;			 
  char **h_aliases;		 
  int h_addrtype;		 
  int h_length;			 
  char **h_addr_list;		 

};

 

extern void sethostent (int __stay_open)  ;

 
extern void endhostent (void)  ;

 

extern struct hostent *gethostent (void)  ;

 

extern struct hostent *gethostbyaddr (__const void *__addr, __socklen_t __len,
				      int __type)  ;

 
extern struct hostent *gethostbyname (__const char *__name)  ;


 


extern struct hostent *gethostbyname2 (__const char *__name, int __af)  ;

 




extern int gethostent_r (struct hostent *__restrict __result_buf,
			 char *__restrict __buf, size_t __buflen,
			 struct hostent **__restrict __result,
			 int *__restrict __h_errnop)  ;

extern int gethostbyaddr_r (__const void *__restrict __addr, __socklen_t __len,
			    int __type,
			    struct hostent *__restrict __result_buf,
			    char *__restrict __buf, size_t __buflen,
			    struct hostent **__restrict __result,
			    int *__restrict __h_errnop)  ;

extern int gethostbyname_r (__const char *__restrict __name,
			    struct hostent *__restrict __result_buf,
			    char *__restrict __buf, size_t __buflen,
			    struct hostent **__restrict __result,
			    int *__restrict __h_errnop)  ;

extern int gethostbyname2_r (__const char *__restrict __name, int __af,
			     struct hostent *__restrict __result_buf,
			     char *__restrict __buf, size_t __buflen,
			     struct hostent **__restrict __result,
			     int *__restrict __h_errnop)  ;



 

extern void setnetent (int __stay_open)  ;

 
extern void endnetent (void)  ;

 

extern struct netent *getnetent (void)  ;

 

extern struct netent *getnetbyaddr (uint32_t __net, int __type)
      ;

 
extern struct netent *getnetbyname (__const char *__name)  ;


 




extern int getnetent_r (struct netent *__restrict __result_buf,
			char *__restrict __buf, size_t __buflen,
			struct netent **__restrict __result,
			int *__restrict __h_errnop)  ;

extern int getnetbyaddr_r (uint32_t __net, int __type,
			   struct netent *__restrict __result_buf,
			   char *__restrict __buf, size_t __buflen,
			   struct netent **__restrict __result,
			   int *__restrict __h_errnop)  ;

extern int getnetbyname_r (__const char *__restrict __name,
			   struct netent *__restrict __result_buf,
			   char *__restrict __buf, size_t __buflen,
			   struct netent **__restrict __result,
			   int *__restrict __h_errnop)  ;



 
struct servent
{
  char *s_name;			 
  char **s_aliases;		 
  int s_port;			 
  char *s_proto;		 
};

 

extern void setservent (int __stay_open)  ;

 
extern void endservent (void)  ;

 

extern struct servent *getservent (void)  ;

 

extern struct servent *getservbyname (__const char *__name,
				      __const char *__proto)  ;

 

extern struct servent *getservbyport (int __port, __const char *__proto)
      ;



 

extern int getservent_r (struct servent *__restrict __result_buf,
			 char *__restrict __buf, size_t __buflen,
			 struct servent **__restrict __result)  ;

extern int getservbyname_r (__const char *__restrict __name,
			    __const char *__restrict __proto,
			    struct servent *__restrict __result_buf,
			    char *__restrict __buf, size_t __buflen,
			    struct servent **__restrict __result)  ;

extern int getservbyport_r (int __port, __const char *__restrict __proto,
			    struct servent *__restrict __result_buf,
			    char *__restrict __buf, size_t __buflen,
			    struct servent **__restrict __result)  ;



 
struct protoent
{
  char *p_name;			 
  char **p_aliases;		 
  int p_proto;			 
};

 

extern void setprotoent (int __stay_open)  ;

 
extern void endprotoent (void)  ;

 

extern struct protoent *getprotoent (void)  ;

 
extern struct protoent *getprotobyname (__const char *__name)  ;

 
extern struct protoent *getprotobynumber (int __proto)  ;



 

extern int getprotoent_r (struct protoent *__restrict __result_buf,
			  char *__restrict __buf, size_t __buflen,
			  struct protoent **__restrict __result)  ;

extern int getprotobyname_r (__const char *__restrict __name,
			     struct protoent *__restrict __result_buf,
			     char *__restrict __buf, size_t __buflen,
			     struct protoent **__restrict __result)  ;

extern int getprotobynumber_r (int __proto,
			       struct protoent *__restrict __result_buf,
			       char *__restrict __buf, size_t __buflen,
			       struct protoent **__restrict __result)  ;



 
extern int setnetgrent (__const char *__netgroup)  ;

 
extern void endnetgrent (void)  ;

 

extern int getnetgrent (char **__restrict __hostp,
			char **__restrict __userp,
			char **__restrict __domainp)  ;


 
extern int innetgr (__const char *__netgroup, __const char *__host,
		    __const char *__user, __const char *domain)  ;

 
extern int getnetgrent_r (char **__restrict __hostp,
			  char **__restrict __userp,
			  char **__restrict __domainp,
			  char *__restrict __buffer, size_t __buflen)  ;




 





extern int rcmd (char **__restrict __ahost, unsigned short int __rport,
		 __const char *__restrict __locuser,
		 __const char *__restrict __remuser,
		 __const char *__restrict __cmd, int *__restrict __fd2p)
      ;

 

extern int rcmd_af (char **__restrict __ahost, unsigned short int __rport,
		    __const char *__restrict __locuser,
		    __const char *__restrict __remuser,
		    __const char *__restrict __cmd, int *__restrict __fd2p,
		    sa_family_t __af)  ;

 




extern int rexec (char **__restrict __ahost, int __rport,
		  __const char *__restrict __name,
		  __const char *__restrict __pass,
		  __const char *__restrict __cmd, int *__restrict __fd2p)
      ;

 

extern int rexec_af (char **__restrict __ahost, int __rport,
		     __const char *__restrict __name,
		     __const char *__restrict __pass,
		     __const char *__restrict __cmd, int *__restrict __fd2p,
		     sa_family_t __af)  ;

 


extern int ruserok (__const char *__rhost, int __suser,
		    __const char *__remuser, __const char *__locuser)  ;

 

extern int ruserok_af (__const char *__rhost, int __suser,
		       __const char *__remuser, __const char *__locuser,
		       sa_family_t __af)  ;

 


extern int rresvport (int *__alport)  ;

 

extern int rresvport_af (int *__alport, sa_family_t __af)  ;



 

 
struct addrinfo
{
  int ai_flags;			 
  int ai_family;		 
  int ai_socktype;		 
  int ai_protocol;		 
  socklen_t ai_addrlen;		 
  struct sockaddr *ai_addr;	 
  char *ai_canonname;		 
  struct addrinfo *ai_next;	 
};

# 438 "/usr/include/netdb.h" 3


 




 




























 

extern int getaddrinfo (__const char *__restrict __name,
			__const char *__restrict __service,
			__const struct addrinfo *__restrict __req,
			struct addrinfo **__restrict __pai)  ;

 
extern void freeaddrinfo (struct addrinfo *__ai)  ;

 
extern __const char *gai_strerror (int __ecode)  ;

 
extern int getnameinfo (__const struct sockaddr *__restrict __sa,
			socklen_t __salen, char *__restrict __host,
			socklen_t __hostlen, char *__restrict __serv,
			socklen_t __servlen, unsigned int __flags)  ;

# 512 "/usr/include/netdb.h" 3



 


# 67 "comm.c" 2


# 1 "/usr/include/sys/socket.h" 1 3
 























 

# 1 "/usr/include/sys/uio.h" 1 3
 
























 

 
# 1 "/usr/include/bits/uio.h" 1 3
 

























 



 









 
struct iovec
  {
    void *iov_base;	 
    size_t iov_len;	 
  };
# 29 "/usr/include/sys/uio.h" 2 3



 




extern ssize_t readv (int __fd, __const struct iovec *__vector, int __count)
      ;

 




extern ssize_t writev (int __fd, __const struct iovec *__vector, int __count)
      ;

 


# 27 "/usr/include/sys/socket.h" 2 3


# 1 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 1 3






 


# 19 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3



 


 





 


# 61 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 





 


















 





 

 

# 131 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 


# 188 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3





 




 

# 271 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


# 283 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 

# 317 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3




 





















# 29 "/usr/include/sys/socket.h" 2 3



 





 

struct osockaddr
  {
    unsigned short int sa_family;
    unsigned char sa_data[14];
  };


 

enum
{
  SHUT_RD = 0,		 

  SHUT_WR,		 

  SHUT_RDWR		 

};

 








# 94 "/usr/include/sys/socket.h" 3



 


extern int socket (int __domain, int __type, int __protocol)  ;

 



extern int socketpair (int __domain, int __type, int __protocol,
		       int __fds[2])  ;

 
extern int bind (int __fd, __const struct sockaddr *  __addr, socklen_t __len)
      ;

 
extern int getsockname (int __fd, struct sockaddr *__restrict  __addr,
			socklen_t *__restrict __len)  ;

 



extern int connect (int __fd, __const struct sockaddr *  __addr, socklen_t __len)
      ;

 

extern int getpeername (int __fd, struct sockaddr *__restrict  __addr,
			socklen_t *__restrict __len)  ;


 
extern ssize_t send (int __fd, __const void *__buf, size_t __n, int __flags)
      ;

 

extern ssize_t recv (int __fd, void *__buf, size_t __n, int __flags)
      ;

 

extern ssize_t sendto (int __fd, __const void *__buf, size_t __n,
		       int __flags, __const struct sockaddr *  __addr,
		       socklen_t __addr_len)  ;

 



extern ssize_t recvfrom (int __fd, void *__restrict __buf, size_t __n, int __flags,
			 struct sockaddr *__restrict  __addr, socklen_t *__restrict __addr_len)
      ;


 

extern ssize_t sendmsg (int __fd, __const struct msghdr *__message, int __flags)
      ;

 

extern ssize_t recvmsg (int __fd, struct msghdr *__message, int __flags)
      ;


 


extern int getsockopt (int __fd, int __level, int __optname,
		       void *__restrict __optval,
		       socklen_t *__restrict __optlen)  ;

 


extern int setsockopt (int __fd, int __level, int __optname,
		       __const void *__optval, socklen_t __optlen)  ;


 


extern int listen (int __fd, int __n)  ;

 




extern int accept (int __fd, struct sockaddr *__restrict  __addr,
		   socklen_t *__restrict __addr_len)
      ;

 





extern int shutdown (int __fd, int __how)  ;









 


extern int isfdtype (int __fd, int __fdtype)  ;


 


# 69 "comm.c" 2

# 1 "/usr/include/arpa/inet.h" 1 3
 























 





 

 

extern in_addr_t inet_addr (__const char *__cp)  ;

 
extern in_addr_t inet_lnaof (struct in_addr __in)  ;

 

extern struct in_addr inet_makeaddr (in_addr_t __net, in_addr_t __host)
      ;

 
extern in_addr_t inet_netof (struct in_addr __in)  ;

 

extern in_addr_t inet_network (__const char *__cp)  ;

 

extern char *inet_ntoa (struct in_addr __in)  ;

 


extern int inet_pton (int __af, __const char *__restrict __cp,
		      void *__restrict __buf)  ;

 


extern __const char *inet_ntop (int __af, __const void *__restrict __cp,
				char *__restrict __buf, socklen_t __len)
      ;


 

 

extern in_addr_t inet_aton (__const char *__cp, struct in_addr *__inp)  ;

 

extern char *inet_neta (in_addr_t __net, char *__buf, size_t __len)  ;

 


extern char *inet_net_ntop (int __af, __const void *__cp, int __bits,
			    char *__buf, size_t __len)  ;

 


extern int inet_net_pton (int __af, __const char *__cp,
			  void *__buf, size_t __len)  ;

 


extern unsigned int inet_nsap_addr (__const char *__cp,
				    unsigned char *__buf, int __len)  ;

 

extern char *inet_nsap_ntoa (int __len, __const unsigned char *__cp,
			     char *__buf)  ;


 


# 70 "comm.c" 2

# 1 "/usr/include/arpa/telnet.h" 1 3
 

































 
































extern char *telcmds[];








 












































# 140 "/usr/include/arpa/telnet.h" 3


 











 















 



























 











extern char *slc_names[];



























 



 






 




















extern char *authtype_names[];





 


















# 304 "/usr/include/arpa/telnet.h" 3

extern char *encrypt_names[];
extern char *enctype_names[];










# 71 "comm.c" 2

int	close		  ( int fd )   ;



# 1 "/usr/include/signal.h" 1 3
 

















 











 

# 1 "/usr/include/bits/sigset.h" 1 3
 


















# 33 "/usr/include/bits/sigset.h" 3



 












 



 














# 97 "/usr/include/bits/sigset.h" 3



 


extern int __sigismember (__const __sigset_t *, int);
extern int __sigaddset (__sigset_t *, int);
extern int __sigdelset (__sigset_t *, int);











extern __inline  int	 __sigismember  (  __const  __sigset_t *__set, int __sig)	{	unsigned long int __mask = (((unsigned long int) 1) << ((( __sig ) - 1) % (8 * sizeof (unsigned long int)))) ;	unsigned long int __word = ((( __sig ) - 1) / (8 * sizeof (unsigned long int))) ;	return   (__set->__val[__word] & __mask) ? 1 : 0 ;	} 
extern __inline  int	 __sigaddset  (    __sigset_t *__set, int __sig)	{	unsigned long int __mask = (((unsigned long int) 1) << ((( __sig ) - 1) % (8 * sizeof (unsigned long int)))) ;	unsigned long int __word = ((( __sig ) - 1) / (8 * sizeof (unsigned long int))) ;	return   ((__set->__val[__word] |= __mask), 0) ;	} 
extern __inline  int	 __sigdelset  (    __sigset_t *__set, int __sig)	{	unsigned long int __mask = (((unsigned long int) 1) << ((( __sig ) - 1) % (8 * sizeof (unsigned long int)))) ;	unsigned long int __word = ((( __sig ) - 1) / (8 * sizeof (unsigned long int))) ;	return   ((__set->__val[__word] &= ~__mask), 0) ;	} 






# 33 "/usr/include/signal.h" 2 3


 




typedef __sig_atomic_t sig_atomic_t;















# 1 "/usr/include/bits/signum.h" 1 3
 




















 









 










































 





# 56 "/usr/include/signal.h" 2 3


# 67 "/usr/include/signal.h" 3



 
typedef void (*__sighandler_t) (int);

 


extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler)
      ;





 



extern __sighandler_t signal (int __sig, __sighandler_t __handler)  ;
# 98 "/usr/include/signal.h" 3








 



extern int kill (__pid_t __pid, int __sig)  ;



 


extern int killpg (__pid_t __pgrp, int __sig)  ;


 
extern int raise (int __sig)  ;


 
extern __sighandler_t ssignal (int __sig, __sighandler_t __handler)  ;
extern int gsignal (int __sig)  ;



 
extern void psignal (int __sig, __const char *__s)  ;



 




extern int __sigpause (int __sig_or_mask, int __is_sig)  ;


 

extern int sigpause (int __mask)  ;

# 155 "/usr/include/signal.h" 3




 




 


 
extern int sigblock (int __mask)  ;

 
extern int sigsetmask (int __mask)  ;

 
extern int siggetmask (void)  ;











 

typedef __sighandler_t sig_t;





 



 
# 1 "/usr/include/bits/siginfo.h" 1 3
 























# 1 "/usr/include/bits/wordsize.h" 1 3
 


















# 25 "/usr/include/bits/siginfo.h" 2 3







 
typedef union sigval
  {
    int sival_int;
    void *sival_ptr;
  } sigval_t;













typedef struct siginfo
  {
    int si_signo;		 
    int si_errno;		 

    int si_code;		 

    union
      {
	int _pad[((128  / sizeof (int)) - 3) ];

	  
	struct
	  {
	    __pid_t si_pid;	 
	    __uid_t si_uid;	 
	  } _kill;

	 
	struct
	  {
	    unsigned int _timer1;
	    unsigned int _timer2;
	  } _timer;

	 
	struct
	  {
	    __pid_t si_pid;	 
	    __uid_t si_uid;	 
	    sigval_t si_sigval;	 
	  } _rt;

	 
	struct
	  {
	    __pid_t si_pid;	 
	    __uid_t si_uid;	 
	    int si_status;	 
	    __clock_t si_utime;
	    __clock_t si_stime;
	  } _sigchld;

	 
	struct
	  {
	    void *si_addr;	 
	  } _sigfault;

	 
	struct
	  {
	    long int si_band;	 
	    int si_fd;
	  } _sigpoll;
      } _sifields;
  } siginfo_t;


 















 

enum
{
  SI_ASYNCNL = -6,		 

  SI_SIGIO,			 

  SI_ASYNCIO,			 

  SI_MESGQ,			 

  SI_TIMER,			 

  SI_QUEUE,			 

  SI_USER,			 

  SI_KERNEL = 0x80		 

};


 
enum
{
  ILL_ILLOPC = 1,		 

  ILL_ILLOPN,			 

  ILL_ILLADR,			 

  ILL_ILLTRP,			 

  ILL_PRVOPC,			 

  ILL_PRVREG,			 

  ILL_COPROC,			 

  ILL_BADSTK			 

};

 
enum
{
  FPE_INTDIV = 1,		 

  FPE_INTOVF,			 

  FPE_FLTDIV,			 

  FPE_FLTOVF,			 

  FPE_FLTUND,			 

  FPE_FLTRES,			 

  FPE_FLTINV,			 

  FPE_FLTSUB			 

};

 
enum
{
  SEGV_MAPERR = 1,		 

  SEGV_ACCERR			 

};

 
enum
{
  BUS_ADRALN = 1,		 

  BUS_ADRERR,			 

  BUS_OBJERR			 

};

 
enum
{
  TRAP_BRKPT = 1,		 

  TRAP_TRACE			 

};

 
enum
{
  CLD_EXITED = 1,		 

  CLD_KILLED,			 

  CLD_DUMPED,			 

  CLD_TRAPPED,			 

  CLD_STOPPED,			 

  CLD_CONTINUED			 

};

 
enum
{
  POLL_IN = 1,			 

  POLL_OUT,			 

  POLL_MSG,			 

  POLL_ERR,			 

  POLL_PRI,			 

  POLL_HUP			 

};









 







 
struct __pthread_attr_s;

typedef struct sigevent
  {
    sigval_t sigev_value;
    int sigev_signo;
    int sigev_notify;

    union
      {
	int _pad[((64  / sizeof (int)) - 3) ];

	struct
	  {
	    void (*_function) (sigval_t);	   
	    struct __pthread_attr_s *_attribute;   
	  } _sigev_thread;
      } _sigev_un;
  } sigevent_t;

 



 
enum
{
  SIGEV_SIGNAL = 0,		 

  SIGEV_NONE,			 

  SIGEV_THREAD			 

};


# 199 "/usr/include/signal.h" 2 3



 
extern int sigemptyset (sigset_t *__set)  ;

 
extern int sigfillset (sigset_t *__set)  ;

 
extern int sigaddset (sigset_t *__set, int __signo)  ;

 
extern int sigdelset (sigset_t *__set, int __signo)  ;

 
extern int sigismember (__const sigset_t *__set, int __signo)  ;

# 228 "/usr/include/signal.h" 3


 

# 1 "/usr/include/bits/sigaction.h" 1 3
 






















 
struct sigaction
  {
     

    union
      {
	 
	__sighandler_t sa_handler;
	 
	void (*sa_sigaction) (int, siginfo_t *, void *);
      }
    __sigaction_handler;






     
    __sigset_t sa_mask;

     
    int sa_flags;

     
    void (*sa_restorer) (void);
  };

 














 





 



# 232 "/usr/include/signal.h" 2 3


 
extern int sigprocmask (int __how, __const sigset_t *__restrict __set,
			sigset_t *__restrict __oset)  ;

 

extern int sigsuspend (__const sigset_t *__set)  ;

 
extern int sigaction (int __sig, __const struct sigaction *__restrict __act,
		      struct sigaction *__restrict __oact)  ;

 
extern int sigpending (sigset_t *__set)  ;


 
extern int sigwait (__const sigset_t *__restrict __set, int *__restrict __sig)
      ;


 
extern int sigwaitinfo (__const sigset_t *__restrict __set,
			siginfo_t *__restrict __info)  ;

 

extern int sigtimedwait (__const sigset_t *__restrict __set,
			 siginfo_t *__restrict __info,
			 __const struct timespec *__restrict __timeout)
      ;

 

extern int sigqueue (__pid_t __pid, int __sig, __const union sigval __val)
      ;






 

extern __const char *__const _sys_siglist[64 ];
extern __const char *__const sys_siglist[64 ];

 
struct sigvec
  {
    __sighandler_t sv_handler;	 
    int sv_mask;		 

    int sv_flags;		 

  };

 





 




extern int sigvec (int __sig, __const struct sigvec *__vec,
		   struct sigvec *__ovec)  ;


 
# 1 "/usr/include/bits/sigcontext.h" 1 3
 






















 



# 1 "/usr/include/asm/sigcontext.h" 1 3



 













struct _fpreg {
	unsigned short significand[4];
	unsigned short exponent;
};

struct _fpxreg {
	unsigned short significand[4];
	unsigned short exponent;
	unsigned short padding[3];
};

struct _xmmreg {
	unsigned long element[4];
};

struct _fpstate {
	 
	unsigned long 	cw;
	unsigned long	sw;
	unsigned long	tag;
	unsigned long	ipoff;
	unsigned long	cssel;
	unsigned long	dataoff;
	unsigned long	datasel;
	struct _fpreg	_st[8];
	unsigned short	status;
	unsigned short	magic;		 

	 
	unsigned long	_fxsr_env[6];	 
	unsigned long	mxcsr;
	unsigned long	reserved;
	struct _fpxreg	_fxsr_st[8];	 
	struct _xmmreg	_xmm[8];
	unsigned long	padding[56];
};



struct sigcontext {
	unsigned short gs, __gsh;
	unsigned short fs, __fsh;
	unsigned short es, __esh;
	unsigned short ds, __dsh;
	unsigned long edi;
	unsigned long esi;
	unsigned long ebp;
	unsigned long esp;
	unsigned long ebx;
	unsigned long edx;
	unsigned long ecx;
	unsigned long eax;
	unsigned long trapno;
	unsigned long err;
	unsigned long eip;
	unsigned short cs, __csh;
	unsigned long eflags;
	unsigned long esp_at_signal;
	unsigned short ss, __ssh;
	struct _fpstate * fpstate;
	unsigned long oldmask;
	unsigned long cr2;
};



# 28 "/usr/include/bits/sigcontext.h" 2 3


# 307 "/usr/include/signal.h" 2 3


 
extern int sigreturn (struct sigcontext *__scp)  ;






 


extern int siginterrupt (int __sig, int __interrupt)  ;

# 1 "/usr/include/bits/sigstack.h" 1 3
 























 
struct sigstack
  {
    void *ss_sp;		 
    int ss_onstack;		 
  };


 
enum
{
  SS_ONSTACK = 1,

  SS_DISABLE

};

 


 



 
typedef struct sigaltstack
  {
    void *ss_sp;
    int ss_flags;
    size_t ss_size;
  } stack_t;
# 322 "/usr/include/signal.h" 2 3





 


extern int sigstack (struct sigstack *__ss, struct sigstack *__oss)  ;

 

extern int sigaltstack (__const struct sigaltstack *__restrict __ss,
			struct sigaltstack *__restrict __oss)  ;



# 353 "/usr/include/signal.h" 3



 

# 1 "/usr/include/bits/sigthread.h" 1 3
 

























 

 

extern int pthread_sigmask (int __how,
			    __const __sigset_t *__restrict __newmask,
			    __sigset_t *__restrict __oldmask) ;

 
extern int pthread_kill (pthread_t __thread, int __signo)  ;


# 358 "/usr/include/signal.h" 2 3



 


 
extern int __libc_current_sigrtmin (void)  ;
 
extern int __libc_current_sigrtmax (void)  ;



 


# 76 "comm.c" 2

# 1 "/usr/include/unistd.h" 1 3
 

















 








 

 


 



 


 


 


 



 



 



 



 






 


 




 


 


 



 



 



















































































# 1 "/usr/include/bits/posix_opt.h" 1 3
 





















 


 


 


 


 


 


 


 


 


 


 


 


 



 


 


 


 


 


 



 


 


 


 


 


 


 


 


 




 


 


 


 


 


 


 


 


 


 


 


 



# 175 "/usr/include/unistd.h" 2 3


 




 





 










# 1 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 1 3






 


# 19 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3



 


 





 


# 61 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 





 


















 





 

 

# 131 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 


# 188 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3





 




 

# 271 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


# 283 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3


 

 

# 317 "/usr/lib/gcc-lib/i386-slackware-linux/2.95.3/include/stddef.h" 3




 





















# 199 "/usr/include/unistd.h" 2 3


# 236 "/usr/include/unistd.h" 3
















 






 
extern int access (__const char *__name, int __type)  ;








 







 






 





extern __off_t lseek (int __fd, __off_t __offset, int __whence)  ;
# 300 "/usr/include/unistd.h" 3





 
extern int close (int __fd)  ;

 

extern ssize_t read (int __fd, void *__buf, size_t __nbytes)  ;

 
extern ssize_t write (int __fd, __const void *__buf, size_t __n)  ;

# 347 "/usr/include/unistd.h" 3


 



extern int pipe (int __pipedes[2])  ;

 






extern unsigned int alarm (unsigned int __seconds)  ;

 






extern unsigned int sleep (unsigned int __seconds)  ;


 



extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
      ;

 

extern int usleep (__useconds_t __useconds)  ;



 

extern int pause (void)  ;


 
extern int chown (__const char *__file, __uid_t __owner, __gid_t __group)
      ;


 
extern int fchown (int __fd, __uid_t __owner, __gid_t __group)  ;


 

extern int lchown (__const char *__file, __uid_t __owner, __gid_t __group)
      ;



 
extern int chdir (__const char *__path)  ;


 
extern int fchdir (int __fd)  ;


 






extern char *getcwd (char *__buf, size_t __size)  ;









 


extern char *getwd (char *__buf)  ;



 
extern int dup (int __fd)  ;

 
extern int dup2 (int __fd, int __fd2)  ;

 
extern char **__environ;





 

extern int execve (__const char *__path, char *__const __argv[],
		   char *__const __envp[])  ;









 
extern int execv (__const char *__path, char *__const __argv[])  ;

 

extern int execle (__const char *__path, __const char *__arg, ...)  ;

 

extern int execl (__const char *__path, __const char *__arg, ...)  ;

 

extern int execvp (__const char *__file, char *__const __argv[])  ;

 


extern int execlp (__const char *__file, __const char *__arg, ...)  ;



 
extern int nice (int __inc)  ;



 
extern void _exit (int __status) __attribute__ ((__noreturn__));


 


# 1 "/usr/include/bits/confname.h" 1 3
 






















 
enum
  {
    _PC_LINK_MAX,

    _PC_MAX_CANON,

    _PC_MAX_INPUT,

    _PC_NAME_MAX,

    _PC_PATH_MAX,

    _PC_PIPE_BUF,

    _PC_CHOWN_RESTRICTED,

    _PC_NO_TRUNC,

    _PC_VDISABLE,

    _PC_SYNC_IO,

    _PC_ASYNC_IO,

    _PC_PRIO_IO,

    _PC_SOCK_MAXBUF,

    _PC_FILESIZEBITS,

    _PC_REC_INCR_XFER_SIZE,

    _PC_REC_MAX_XFER_SIZE,

    _PC_REC_MIN_XFER_SIZE,

    _PC_REC_XFER_ALIGN,

    _PC_ALLOC_SIZE_MIN,

    _PC_SYMLINK_MAX

  };

 
enum
  {
    _SC_ARG_MAX,

    _SC_CHILD_MAX,

    _SC_CLK_TCK,

    _SC_NGROUPS_MAX,

    _SC_OPEN_MAX,

    _SC_STREAM_MAX,

    _SC_TZNAME_MAX,

    _SC_JOB_CONTROL,

    _SC_SAVED_IDS,

    _SC_REALTIME_SIGNALS,

    _SC_PRIORITY_SCHEDULING,

    _SC_TIMERS,

    _SC_ASYNCHRONOUS_IO,

    _SC_PRIORITIZED_IO,

    _SC_SYNCHRONIZED_IO,

    _SC_FSYNC,

    _SC_MAPPED_FILES,

    _SC_MEMLOCK,

    _SC_MEMLOCK_RANGE,

    _SC_MEMORY_PROTECTION,

    _SC_MESSAGE_PASSING,

    _SC_SEMAPHORES,

    _SC_SHARED_MEMORY_OBJECTS,

    _SC_AIO_LISTIO_MAX,

    _SC_AIO_MAX,

    _SC_AIO_PRIO_DELTA_MAX,

    _SC_DELAYTIMER_MAX,

    _SC_MQ_OPEN_MAX,

    _SC_MQ_PRIO_MAX,

    _SC_VERSION,

    _SC_PAGESIZE,


    _SC_RTSIG_MAX,

    _SC_SEM_NSEMS_MAX,

    _SC_SEM_VALUE_MAX,

    _SC_SIGQUEUE_MAX,

    _SC_TIMER_MAX,


     

    _SC_BC_BASE_MAX,

    _SC_BC_DIM_MAX,

    _SC_BC_SCALE_MAX,

    _SC_BC_STRING_MAX,

    _SC_COLL_WEIGHTS_MAX,

    _SC_EQUIV_CLASS_MAX,

    _SC_EXPR_NEST_MAX,

    _SC_LINE_MAX,

    _SC_RE_DUP_MAX,

    _SC_CHARCLASS_NAME_MAX,


    _SC_2_VERSION,

    _SC_2_C_BIND,

    _SC_2_C_DEV,

    _SC_2_FORT_DEV,

    _SC_2_FORT_RUN,

    _SC_2_SW_DEV,

    _SC_2_LOCALEDEF,


    _SC_PII,

    _SC_PII_XTI,

    _SC_PII_SOCKET,

    _SC_PII_INTERNET,

    _SC_PII_OSI,

    _SC_POLL,

    _SC_SELECT,

    _SC_UIO_MAXIOV,

    _SC_IOV_MAX = _SC_UIO_MAXIOV ,

    _SC_PII_INTERNET_STREAM,

    _SC_PII_INTERNET_DGRAM,

    _SC_PII_OSI_COTS,

    _SC_PII_OSI_CLTS,

    _SC_PII_OSI_M,

    _SC_T_IOV_MAX,


     
    _SC_THREADS,

    _SC_THREAD_SAFE_FUNCTIONS,

    _SC_GETGR_R_SIZE_MAX,

    _SC_GETPW_R_SIZE_MAX,

    _SC_LOGIN_NAME_MAX,

    _SC_TTY_NAME_MAX,

    _SC_THREAD_DESTRUCTOR_ITERATIONS,

    _SC_THREAD_KEYS_MAX,

    _SC_THREAD_STACK_MIN,

    _SC_THREAD_THREADS_MAX,

    _SC_THREAD_ATTR_STACKADDR,

    _SC_THREAD_ATTR_STACKSIZE,

    _SC_THREAD_PRIORITY_SCHEDULING,

    _SC_THREAD_PRIO_INHERIT,

    _SC_THREAD_PRIO_PROTECT,

    _SC_THREAD_PROCESS_SHARED,


    _SC_NPROCESSORS_CONF,

    _SC_NPROCESSORS_ONLN,

    _SC_PHYS_PAGES,

    _SC_AVPHYS_PAGES,

    _SC_ATEXIT_MAX,

    _SC_PASS_MAX,


    _SC_XOPEN_VERSION,

    _SC_XOPEN_XCU_VERSION,

    _SC_XOPEN_UNIX,

    _SC_XOPEN_CRYPT,

    _SC_XOPEN_ENH_I18N,

    _SC_XOPEN_SHM,


    _SC_2_CHAR_TERM,

    _SC_2_C_VERSION,

    _SC_2_UPE,


    _SC_XOPEN_XPG2,

    _SC_XOPEN_XPG3,

    _SC_XOPEN_XPG4,


    _SC_CHAR_BIT,

    _SC_CHAR_MAX,

    _SC_CHAR_MIN,

    _SC_INT_MAX,

    _SC_INT_MIN,

    _SC_LONG_BIT,

    _SC_WORD_BIT,

    _SC_MB_LEN_MAX,

    _SC_NZERO,

    _SC_SSIZE_MAX,

    _SC_SCHAR_MAX,

    _SC_SCHAR_MIN,

    _SC_SHRT_MAX,

    _SC_SHRT_MIN,

    _SC_UCHAR_MAX,

    _SC_UINT_MAX,

    _SC_ULONG_MAX,

    _SC_USHRT_MAX,


    _SC_NL_ARGMAX,

    _SC_NL_LANGMAX,

    _SC_NL_MSGMAX,

    _SC_NL_NMAX,

    _SC_NL_SETMAX,

    _SC_NL_TEXTMAX,


    _SC_XBS5_ILP32_OFF32,

    _SC_XBS5_ILP32_OFFBIG,

    _SC_XBS5_LP64_OFF64,

    _SC_XBS5_LPBIG_OFFBIG,


    _SC_XOPEN_LEGACY,

    _SC_XOPEN_REALTIME,

    _SC_XOPEN_REALTIME_THREADS,


    _SC_ADVISORY_INFO,

    _SC_BARRIERS,

    _SC_BASE,

    _SC_C_LANG_SUPPORT,

    _SC_C_LANG_SUPPORT_R,

    _SC_CLOCK_SELECTION,

    _SC_CPUTIME,

    _SC_THREAD_CPUTIME,

    _SC_DEVICE_IO,

    _SC_DEVICE_SPECIFIC,

    _SC_DEVICE_SPECIFIC_R,

    _SC_FD_MGMT,

    _SC_FIFO,

    _SC_PIPE,

    _SC_FILE_ATTRIBUTES,

    _SC_FILE_LOCKING,

    _SC_FILE_SYSTEM,

    _SC_MONOTONIC_CLOCK,

    _SC_MULTI_PROCESS,

    _SC_SINGLE_PROCESS,

    _SC_NETWORKING,

    _SC_READER_WRITER_LOCKS,

    _SC_SPIN_LOCKS,

    _SC_REGEXP,

    _SC_REGEX_VERSION,

    _SC_SHELL,

    _SC_SIGNALS,

    _SC_SPAWN,

    _SC_SPORADIC_SERVER,

    _SC_THREAD_SPORADIC_SERVER,

    _SC_SYSTEM_DATABASE,

    _SC_SYSTEM_DATABASE_R,

    _SC_TIMEOUTS,

    _SC_TYPED_MEMORY_OBJECTS,

    _SC_USER_GROUPS,

    _SC_USER_GROUPS_R,

    _SC_2_PBS,

    _SC_2_PBS_ACCOUNTING,

    _SC_2_PBS_LOCATE,

    _SC_2_PBS_MESSAGE,

    _SC_2_PBS_TRACK,

    _SC_SYMLOOP_MAX,

    _SC_STREAMS,

    _SC_2_PBS_CHECKPOINT,


    _SC_V6_ILP32_OFF32,

    _SC_V6_ILP32_OFFBIG,

    _SC_V6_LP64_OFF64,

    _SC_V6_LPBIG_OFFBIG,


    _SC_HOST_NAME_MAX,

    _SC_TRACE,

    _SC_TRACE_EVENT_FILTER,

    _SC_TRACE_INHERIT,

    _SC_TRACE_LOG

  };




 
enum
  {
    _CS_PATH,			 


# 492 "/usr/include/bits/confname.h" 3


# 527 "/usr/include/bits/confname.h" 3

# 561 "/usr/include/bits/confname.h" 3


    _CS_V6_WIDTH_RESTRICTED_ENVS

  };

# 500 "/usr/include/unistd.h" 2 3


 
extern long int pathconf (__const char *__path, int __name)  ;

 
extern long int fpathconf (int __fd, int __name)  ;

 
extern long int sysconf (int __name)   __attribute__ ((__const__));


 
extern size_t confstr (int __name, char *__buf, size_t __len)  ;



 
extern __pid_t getpid (void)  ;

 
extern __pid_t getppid (void)  ;

 


extern __pid_t getpgrp (void)  ;








 
extern __pid_t __getpgid (__pid_t __pid)  ;





 


extern int setpgid (__pid_t __pid, __pid_t __pgid)  ;


 











 

extern int setpgrp (void)  ;

# 574 "/usr/include/unistd.h" 3



 


extern __pid_t setsid (void)  ;






 
extern __uid_t getuid (void)  ;

 
extern __uid_t geteuid (void)  ;

 
extern __gid_t getgid (void)  ;

 
extern __gid_t getegid (void)  ;

 


extern int getgroups (int __size, __gid_t __list[])  ;






 



extern int setuid (__uid_t __uid)  ;


 

extern int setreuid (__uid_t __ruid, __uid_t __euid)  ;



 
extern int seteuid (__uid_t __uid)  ;


 



extern int setgid (__gid_t __gid)  ;


 

extern int setregid (__gid_t __rgid, __gid_t __egid)  ;



 
extern int setegid (__gid_t __gid)  ;



 


extern __pid_t fork (void)  ;


 



extern __pid_t vfork (void)  ;



 

extern char *ttyname (int __fd)  ;

 

extern int ttyname_r (int __fd, char *__buf, size_t __buflen)  ;

 

extern int isatty (int __fd)  ;



 

extern int ttyslot (void)  ;



 
extern int link (__const char *__from, __const char *__to)  ;


 
extern int symlink (__const char *__from, __const char *__to)  ;

 


extern int readlink (__const char *__restrict __path, char *__restrict __buf,
		     size_t __len)  ;


 
extern int unlink (__const char *__name)  ;

 
extern int rmdir (__const char *__path)  ;


 
extern __pid_t tcgetpgrp (int __fd)  ;

 
extern int tcsetpgrp (int __fd, __pid_t __pgrp_id)  ;


 
extern char *getlogin (void)  ;








 
extern int setlogin (__const char *__name)  ;




 



# 1 "/usr/include/getopt.h" 1 3
 
























 














 





extern char *optarg;

 











extern int optind;

 


extern int opterr;

 

extern int optopt;

# 113 "/usr/include/getopt.h" 3



 

























 


extern int getopt (int ___argc, char *const *___argv, const char *__shortopts);




# 163 "/usr/include/getopt.h" 3

# 172 "/usr/include/getopt.h" 3






 



# 726 "/usr/include/unistd.h" 2 3





 


extern int gethostname (char *__name, size_t __len)  ;




 

extern int sethostname (__const char *__name, size_t __len)  ;

 

extern int sethostid (long int __id)  ;


 


extern int getdomainname (char *__name, size_t __len)  ;
extern int setdomainname (__const char *__name, size_t __len)  ;


 


extern int vhangup (void)  ;

 
extern int revoke (__const char *__file)  ;


 




extern int profil (unsigned short int *__sample_buffer, size_t __size,
		   size_t __offset, unsigned int __scale)  ;


 


extern int acct (__const char *__name)  ;


 
extern char *getusershell (void)  ;
extern void endusershell (void)  ;  
extern void setusershell (void)  ;  


 


extern int daemon (int __nochdir, int __noclose)  ;




 

extern int chroot (__const char *__path)  ;

 

extern char *getpass (__const char *__prompt)  ;




 
extern int fsync (int __fd)  ;





 
extern long int gethostid (void)  ;

 
extern void sync (void)  ;


 

extern int getpagesize (void)    __attribute__ ((__const__));


 

extern int truncate (__const char *__file, __off_t __length)  ;
# 834 "/usr/include/unistd.h" 3





 

extern int ftruncate (int __fd, __off_t __length)  ;













 

extern int getdtablesize (void)  ;






 

extern int brk (void *__addr)  ;

 



extern void *sbrk (intptr_t __delta)  ;




 









extern long int syscall (long int __sysno, ...)  ;




# 919 "/usr/include/unistd.h" 3



# 933 "/usr/include/unistd.h" 3



 

extern int fdatasync (int __fildes)  ;



 

# 959 "/usr/include/unistd.h" 3



 








 

 









extern int pthread_atfork (void (*__prepare) (void),
			   void (*__parent) (void),
			   void (*__child) (void))  ;


 


# 77 "comm.c" 2

# 1 "/usr/include/sys/resource.h" 1 3
 






















 
# 1 "/usr/include/bits/resource.h" 1 3
 
























 




 
enum __rlimit_resource
{
   
  RLIMIT_CPU = 0,


   
  RLIMIT_FSIZE = 1,


   
  RLIMIT_DATA = 2,


   
  RLIMIT_STACK = 3,


   
  RLIMIT_CORE = 4,


   



  RLIMIT_RSS = 5,


   
  RLIMIT_NOFILE = 7,
  RLIMIT_OFILE = RLIMIT_NOFILE,  



   
  RLIMIT_AS = 9,


   
  RLIMIT_NPROC = 6,


   
  RLIMIT_MEMLOCK = 8,


   
  RLIMIT_LOCKS = 10,


  RLIMIT_NLIMITS = 11,
  RLIM_NLIMITS = RLIMIT_NLIMITS


};

 










 




 

typedef __rlim_t rlim_t;







struct rlimit
  {
     
    rlim_t rlim_cur;
     
    rlim_t rlim_max;
  };

# 131 "/usr/include/bits/resource.h" 3


 
enum __rusage_who
{
   
  RUSAGE_SELF = 0,


   
  RUSAGE_CHILDREN = -1,


   
  RUSAGE_BOTH = -2

};


# 1 "/usr/include/bits/time.h" 1 3
 


















 



# 57 "/usr/include/bits/time.h" 3




# 72 "/usr/include/bits/time.h" 3


# 150 "/usr/include/bits/resource.h" 2 3


 
struct rusage
  {
     
    struct timeval ru_utime;
     
    struct timeval ru_stime;
     
    long int ru_maxrss;
     

    long int ru_ixrss;
     
    long int ru_idrss;
     
    long int ru_isrss;
     

    long int ru_minflt;
     
    long int ru_majflt;
     
    long int ru_nswap;
     

    long int ru_inblock;
     
    long int ru_oublock;
     
    long int ru_msgsnd;
     
    long int ru_msgrcv;
     
    long int ru_nsignals;
     


    long int ru_nvcsw;
     

    long int ru_nivcsw;
  };

 



 

enum __priority_which
{
  PRIO_PROCESS = 0,		 

  PRIO_PGRP = 1,		 

  PRIO_USER = 2			 

};
# 25 "/usr/include/sys/resource.h" 2 3







 

 








typedef int __rlimit_resource_t;
typedef int __rusage_who_t;
typedef int __priority_which_t;


 


extern int getrlimit (__rlimit_resource_t __resource,
		      struct rlimit *__rlimits)  ;
# 61 "/usr/include/sys/resource.h" 3






 



extern int setrlimit (__rlimit_resource_t __resource,
		      __const struct rlimit *__rlimits)  ;
# 81 "/usr/include/sys/resource.h" 3






 

extern int getrusage (__rusage_who_t __who, struct rusage *__usage)  ;

 



extern int getpriority (__priority_which_t __which, id_t __who)  ;

 

extern int setpriority (__priority_which_t __which, id_t __who, int __prio)
      ;

 


# 78 "comm.c" 2



void	game_loop_unix		  ( int control )   ;
int	init_socket		  ( int port )   ;
void	init_descriptor		  ( int control )   ;
bool	read_from_descriptor	  ( DESCRIPTOR_DATA *d )   ;
bool	write_to_descriptor	  ( int desc, char *txt, int length )   ;



 







int	close		  ( int fd )   ;
 
int	select		  ( int width, fd_set *readfds, fd_set *writefds,
		fd_set *exceptfds, struct timeval *timeout )   ;
int	socket		  ( int domain, int type, int protocol )   ;
 
int	gettimeofday	  ( struct timeval *tp, struct timezone *tzp )   ;



int	close		  ( int fd )   ;

 


bool	check_reconnect		  ( DESCRIPTOR_DATA *d, char *name,
		bool fConn )   ;
bool	check_kickoff		  ( DESCRIPTOR_DATA *d, char *name,
		bool fConn )   ;
bool	check_newbie_playing   ( DESCRIPTOR_DATA *d, char *name )   ;
bool	check_player_ID		  ( DESCRIPTOR_DATA *d, char *name,
		bool fConn )   ;
bool	check_playing		  ( DESCRIPTOR_DATA *d, char *name )   ;
int	main			  ( int argc, char **argv )   ;
void	nanny			  ( DESCRIPTOR_DATA *d, char *argument )   ;
bool	process_output		  ( DESCRIPTOR_DATA *d, bool fPrompt )   ;
void	read_from_buffer	  ( DESCRIPTOR_DATA *d )   ;
void	stop_idling		  ( CHAR_DATA *ch )   ;
void	bust_a_prompt		  ( DESCRIPTOR_DATA *d )   ;
bool    check_ban                 ( GString *site, int type )   ;
int     port,control;
void 	init_signals   		  (void)   ;
void  lookup_address    (DUMMY_ARG *dummyarg)  ;   
void 	do_auto_shutdown 	  (void)   ;

 


extern void remove_snooper  (CHAR_DATA *ch, CHAR_DATA *victim)  ;
extern void add_descriptor  (DESCRIPTOR_DATA *d)  ;
extern void remove_descriptor  (DESCRIPTOR_DATA *d)  ;

 



 


char *scale[4 ] = {
	"" ,
	"" ,
	"" ,
	"" 
};
extern FILE *		    fpReserve;		 
extern bool		    god;		 
extern bool		    merc_down;		 
extern bool		    wizlock;		 
extern bool            newlock;             
extern char		    str_boot_time[160 ];
extern char		    crypt_pwd[160 ];
extern time_t		    current_time;	 
extern time_t			boot_time;


void sig_handler(int sig)
{
	switch(sig)
	{
		case 7 :
			 
			 
             
			break;
		case 15 :
			 
			 
             
			break;
		case 6 :
			 
			 
             
			break;
		case 11 :
			 
			 
             
			break;
	}
}

void init_signals()
{
	signal(7 ,sig_handler);
	signal(15 ,sig_handler);
	signal(6 ,sig_handler);
	signal(11 ,sig_handler);
}




 




























































 
int init_socket(int port)
{
	int s;
	struct sockaddr_in sa;
	struct linger ld;
	int reuse = 1;

# 285 "comm.c"

	 
	(__extension__ (__builtin_constant_p (  sizeof(sa) ) && (  sizeof(sa) ) <= 16	? ((  sizeof(sa) ) == 1	? ({ void *__s = (  &sa  );	*((__uint8_t *) __s) = (__uint8_t)     0  ; __s; }) 	: ({ void *__s = (  &sa  );	union {	unsigned int __ui;	unsigned short int __usi;	unsigned char __uc;	} *__u = __s;	__uint8_t __c = (__uint8_t) (    0  );	switch ((unsigned int) (    sizeof(sa)  ))	{	case 15:	__u->__ui = __c * 0x01010101;	__u = __extension__ ((void *) __u + 4);	case 11:	__u->__ui = __c * 0x01010101;	__u = __extension__ ((void *) __u + 4);	case 7:	__u->__ui = __c * 0x01010101;	__u = __extension__ ((void *) __u + 4);	case 3:	__u->__usi = (unsigned short int) __c * 0x0101;	__u = __extension__ ((void *) __u + 2);	__u->__uc = (unsigned char) __c;	break;	case 14:	__u->__ui = __c * 0x01010101;	__u = __extension__ ((void *) __u + 4);	case 10:	__u->__ui = __c * 0x01010101;	__u = __extension__ ((void *) __u + 4);	case 6:	__u->__ui = __c * 0x01010101;	__u = __extension__ ((void *) __u + 4);	case 2:	__u->__usi = (unsigned short int) __c * 0x0101;	break;	case 13:	__u->__ui = __c * 0x01010101;	__u = __extension__ ((void *) __u + 4);	case 9:	__u->__ui = __c * 0x01010101;	__u = __extension__ ((void *) __u + 4);	case 5:	__u->__ui = __c * 0x01010101;	__u = __extension__ ((void *) __u + 4);	case 1:	__u->__uc = (unsigned char) __c;	break;	case 16:	__u->__ui = __c * 0x01010101;	__u = __extension__ ((void *) __u + 4);	case 12:	__u->__ui = __c * 0x01010101;	__u = __extension__ ((void *) __u + 4);	case 8:	__u->__ui = __c * 0x01010101;	__u = __extension__ ((void *) __u + 4);	case 4:	__u->__ui = __c * 0x01010101;	case 0:	break;	}	__s; }) )	: (__builtin_constant_p (  0 ) && (  0 ) == '\0'	? ({ void *__s = ( &sa ); __builtin_memset ( __s , '\0',     sizeof(sa)  ) ; __s; })	: memset ( &sa ,   0 ,   sizeof(sa) )))) ;
	
	s = socket(2  , SOCK_STREAM , 0);
	if (s < 0)
	{
		bug("Init-socket",0);
		exit(1);
	}

	sa.sin_family = 2  ;
	sa.sin_port   = (__extension__	({ register unsigned short int __v;	if (__builtin_constant_p (  port  ))	__v = ((((   port   ) >> 8) & 0xff) | (((   port   ) & 0xff) << 8)) ;	else	__asm__ __volatile__ ("rorw $8, %w0"	: "=r" (__v)	: "0" ((unsigned short int) (  port  ))	: "cc");	__v; }))  ;
	sa.sin_addr.s_addr = (__extension__	({ register unsigned int __v;	if (__builtin_constant_p (  ((in_addr_t) 0x00000000)   ))	__v = ((((   ((in_addr_t) 0x00000000)    ) & 0xff000000) >> 24) | (((   ((in_addr_t) 0x00000000)    ) & 0x00ff0000) >>  8) |	(((   ((in_addr_t) 0x00000000)    ) & 0x0000ff00) <<  8) | (((   ((in_addr_t) 0x00000000)    ) & 0x000000ff) << 24)) ;	else	__asm__ __volatile__ ("rorw $8, %w0;"	"rorl $16, %0;"	"rorw $8, %w0"	: "=r" (__v)	: "0" ((unsigned int) (  ((in_addr_t) 0x00000000)   ))	: "cc");	__v; }))  ;











	ld.l_onoff = 1;
	ld.l_linger = 1000;

  	 









	if (setsockopt(s, 1 , 2 , &reuse, sizeof(reuse)) < 0)
	{
		bug("setsockopt REUSEADDR",0);
		exit(1);
	}

	 


	if (setsockopt(s, 1 , 13 , &ld, sizeof(ld)) < 0)
	{
		bug("setsockopt LINGER",0);
		exit(1);
	}


	if (bind(s, (struct sockaddr *) &sa, sizeof(sa)) < 0)
	{
		 
		close(s);
		exit(1);
	}
	listen(s, 9);
	return(s);
}

 


void shift_buffer(DESCRIPTOR_DATA *d, int i)
{
	int j;

	while ( d->inbuf[i] == '\n' || d->inbuf[i] == '\r' )
		i++;
	for ( j = 0; ( d->inbuf[j] = d->inbuf[i+j] ) != '\0'; j++ )
		;
	return;
}
	
 


void read_from_buffer( DESCRIPTOR_DATA *d )
{
	int i, k, offset;
	
	 
	for (i = 0;d->inbuf[i] != '\0'; i++)
	{
		unsigned char c = d->inbuf[i];
		if (c == 255 )
		{
			offset = parse_telnetcommand(d);
			shift_buffer(d,offset);
		}
	}

	 



	if (d->telnet_option[1 ] == ACTIVE)
	{
		if (d->connected != 9 )
			write_to_descriptor(d->descriptor,"*",0);
		else
			write_to_descriptor(d->descriptor,d->inbuf,0);
	}
     


	if ( d->incomm[0] != '\0' )
		return;
	
     


	for ( i = 0; d->inbuf[i] != '\n' && d->inbuf[i] != '\r'; i++ )
	{
		if ( d->inbuf[i] == '\0' )
			return;
	}
	
     


	for ( i = 0, k = 0; d->inbuf[i] != '\n' && d->inbuf[i] != '\r'; i++ )
	{
		if ( k >= 160  - 2 )
		{
			write_to_descriptor( d->descriptor, "Line too long.\n\r", 0 );
			
	     
			for ( ; d->inbuf[i] != '\0'; i++ )
			{
				if ( d->inbuf[i] == '\n' || d->inbuf[i] == '\r' )
					break;
			}
			d->inbuf[i]   = '\n';
			d->inbuf[i+1] = '\0';
			break;
		}

		if ( d->inbuf[i] == '\b' && k > 0 )
			--k;
		else if ( (((  d->inbuf[i]  ) & ~0x7f) == 0)   && (__ctype_b[(int) ( ( d->inbuf[i] ) )] & (unsigned short int)   _ISprint )   )
			d->incomm[k++] = d->inbuf[i];
	}
	
     


	if ( k == 0 )
		d->incomm[k++] = ' ';
	d->incomm[k] = '\0';
	
     


	if ( k > 1 || d->incomm[0] == '!' )
	{
		if (d->incomm[0] != '!' && __extension__	({ size_t __s1_len, __s2_len;	(__builtin_constant_p (  d->incomm ) && __builtin_constant_p (  d->inlast  )	&& (__s1_len = strlen (  d->incomm ), __s2_len = strlen (  d->inlast  ),	(! ((size_t)(const void *)((   d->incomm  ) + 1) - (size_t)(const void *)(   d->incomm  ) == 1)  || __s1_len >= 4)	&& (! ((size_t)(const void *)((   d->inlast   ) + 1) - (size_t)(const void *)(   d->inlast   ) == 1)  || __s2_len >= 4))	? memcmp ((__const char *) (  d->incomm ), (__const char *) (  d->inlast  ),	(__s1_len < __s2_len ? __s1_len : __s2_len) + 1)	: (__builtin_constant_p (  d->incomm ) && ((size_t)(const void *)((   d->incomm  ) + 1) - (size_t)(const void *)(   d->incomm  ) == 1) 	&& (__s1_len = strlen (  d->incomm ), __s1_len < 4)	? (__builtin_constant_p (  d->inlast  ) && ((size_t)(const void *)((   d->inlast   ) + 1) - (size_t)(const void *)(   d->inlast   ) == 1) 	? (__extension__ ({ register int __result =	(((__const unsigned char *) (__const char *) (   d->incomm  ))[0] - ((__const unsigned char *) (__const char *)(    d->inlast   ))[0]);	if (  __s1_len  > 0 && __result == 0)	{	__result = (((__const unsigned char *)	(__const char *) (   d->incomm  ))[1]	- ((__const unsigned char *)	(__const char *) (    d->inlast   ))[1]);	if (  __s1_len  > 1 && __result == 0)	{	__result =	(((__const unsigned char *)	(__const char *) (   d->incomm  ))[2]	- ((__const unsigned char *)	(__const char *) (    d->inlast   ))[2]);	if (  __s1_len  > 2 && __result == 0)	__result =	(((__const unsigned char *)	(__const char *) (   d->incomm  ))[3]	- ((__const unsigned char *)	(__const char *) (    d->inlast   ))[3]);	}	}	__result; })) 	: (__extension__ ({ __const unsigned char *__s2 =	(__const unsigned char *) (__const char *) (    d->inlast   );	register int __result =	(((__const unsigned char *) (__const char *) (   d->incomm  ))[0] - __s2[0]);	if (  __s1_len  > 0 && __result == 0)	{	__result = (((__const unsigned char *)	(__const char *) (   d->incomm  ))[1] - __s2[1]); if (  __s1_len  > 1 && __result == 0)	{	__result = (((__const unsigned char *)	(__const char *) (   d->incomm  ))[2] - __s2[2]);	if (  __s1_len  > 2 && __result == 0)	__result = (((__const unsigned char *)	(__const char *)  (   d->incomm  ))[3]	- __s2[3]);	}	}	__result; })) )	: (__builtin_constant_p (  d->inlast  ) && ((size_t)(const void *)((   d->inlast   ) + 1) - (size_t)(const void *)(   d->inlast   ) == 1) 	&& (__s2_len = strlen (  d->inlast  ), __s2_len < 4)	? (__builtin_constant_p (  d->incomm ) && ((size_t)(const void *)((   d->incomm  ) + 1) - (size_t)(const void *)(   d->incomm  ) == 1) 	? (__extension__ ({ register int __result =	(((__const unsigned char *) (__const char *) (   d->incomm  ))[0] - ((__const unsigned char *) (__const char *)(    d->inlast   ))[0]);	if (  __s2_len  > 0 && __result == 0)	{	__result = (((__const unsigned char *)	(__const char *) (   d->incomm  ))[1]	- ((__const unsigned char *)	(__const char *) (    d->inlast   ))[1]);	if (  __s2_len  > 1 && __result == 0)	{	__result =	(((__const unsigned char *)	(__const char *) (   d->incomm  ))[2]	- ((__const unsigned char *)	(__const char *) (    d->inlast   ))[2]);	if (  __s2_len  > 2 && __result == 0)	__result =	(((__const unsigned char *)	(__const char *) (   d->incomm  ))[3]	- ((__const unsigned char *)	(__const char *) (    d->inlast   ))[3]);	}	}	__result; })) 	: (__extension__ ({ __const unsigned char *__s1 =	(__const unsigned char *) (__const char *) (   d->incomm  );	register int __result =	__s1[0] - ((__const unsigned char *)	(__const char *) (    d->inlast   ))[0];	if (  __s2_len  > 0 && __result == 0)	{	__result = (__s1[1]	- ((__const unsigned char *)	(__const char *) (    d->inlast   ))[1]);	if (  __s2_len  > 1 && __result == 0)	{	__result =	(__s1[2] - ((__const unsigned char *)	(__const char *) (    d->inlast   ))[2]);	if (  __s2_len  > 2 && __result == 0)	__result =	(__s1[3]	- ((__const unsigned char *)	(__const char *) (    d->inlast   ))[3]);	}	}	__result; })) )	: strcmp (  d->incomm ,   d->inlast  )))); }) )
		{
			d->repeat = 0;
		}
		else
		{
			if ( ++d->repeat >= 30 && d->character && d->connected == 9  )
			{
				if (d != ((void *)0)  && d->character != ((void *)0) )
					sprintf( log_buf, "%s input spamming!", d->character->lasthost->str );
				else
					sprintf( log_buf, "%s input spamming!", d->host->str );
				log_string2( log_buf );
				logchan(log_buf, ((void *)0) , ((void *)0) ,(524288 ) ,0, (12  - 4) );
				write_to_descriptor( d->descriptor,
					"\n\r*** SPAM is Bad, Calm DOWN!!! ***\n\r", 0 );
				str_cpy( d->incomm, "quit" );
			}
			 
			if ( ! __extension__	({ size_t __s1_len, __s2_len;	(__builtin_constant_p ( d->incomm ) && __builtin_constant_p (  "note" )	&& (__s1_len = strlen ( d->incomm ), __s2_len = strlen (  "note" ),	(! ((size_t)(const void *)((  d->incomm  ) + 1) - (size_t)(const void *)(  d->incomm  ) == 1)  || __s1_len >= 4)	&& (! ((size_t)(const void *)((   "note"  ) + 1) - (size_t)(const void *)(   "note"  ) == 1)  || __s2_len >= 4))	? memcmp ((__const char *) ( d->incomm ), (__const char *) (  "note" ),	(__s1_len < __s2_len ? __s1_len : __s2_len) + 1)	: (__builtin_constant_p ( d->incomm ) && ((size_t)(const void *)((  d->incomm  ) + 1) - (size_t)(const void *)(  d->incomm  ) == 1) 	&& (__s1_len = strlen ( d->incomm ), __s1_len < 4)	? (__builtin_constant_p (  "note" ) && ((size_t)(const void *)((   "note"  ) + 1) - (size_t)(const void *)(   "note"  ) == 1) 	? (__extension__ ({ register int __result =	(((__const unsigned char *) (__const char *) (  d->incomm  ))[0] - ((__const unsigned char *) (__const char *)(    "note"  ))[0]);	if (  __s1_len  > 0 && __result == 0)	{	__result = (((__const unsigned char *)	(__const char *) (  d->incomm  ))[1]	- ((__const unsigned char *)	(__const char *) (    "note"  ))[1]);	if (  __s1_len  > 1 && __result == 0)	{	__result =	(((__const unsigned char *)	(__const char *) (  d->incomm  ))[2]	- ((__const unsigned char *)	(__const char *) (    "note"  ))[2]);	if (  __s1_len  > 2 && __result == 0)	__result =	(((__const unsigned char *)	(__const char *) (  d->incomm  ))[3]	- ((__const unsigned char *)	(__const char *) (    "note"  ))[3]);	}	}	__result; })) 	: (__extension__ ({ __const unsigned char *__s2 =	(__const unsigned char *) (__const char *) (    "note"  );	register int __result =	(((__const unsigned char *) (__const char *) (  d->incomm  ))[0] - __s2[0]);	if (  __s1_len  > 0 && __result == 0)	{	__result = (((__const unsigned char *)	(__const char *) (  d->incomm  ))[1] - __s2[1]); if (  __s1_len  > 1 && __result == 0)	{	__result = (((__const unsigned char *)	(__const char *) (  d->incomm  ))[2] - __s2[2]);	if (  __s1_len  > 2 && __result == 0)	__result = (((__const unsigned char *)	(__const char *)  (  d->incomm  ))[3]	- __s2[3]);	}	}	__result; })) )	: (__builtin_constant_p (  "note" ) && ((size_t)(const void *)((   "note"  ) + 1) - (size_t)(const void *)(   "note"  ) == 1) 	&& (__s2_len = strlen (  "note" ), __s2_len < 4)	? (__builtin_constant_p ( d->incomm ) && ((size_t)(const void *)((  d->incomm  ) + 1) - (size_t)(const void *)(  d->incomm  ) == 1) 	? (__extension__ ({ register int __result =	(((__const unsigned char *) (__const char *) (  d->incomm  ))[0] - ((__const unsigned char *) (__const char *)(    "note"  ))[0]);	if (  __s2_len  > 0 && __result == 0)	{	__result = (((__const unsigned char *)	(__const char *) (  d->incomm  ))[1]	- ((__const unsigned char *)	(__const char *) (    "note"  ))[1]);	if (  __s2_len  > 1 && __result == 0)	{	__result =	(((__const unsigned char *)	(__const char *) (  d->incomm  ))[2]	- ((__const unsigned char *)	(__const char *) (    "note"  ))[2]);	if (  __s2_len  > 2 && __result == 0)	__result =	(((__const unsigned char *)	(__const char *) (  d->incomm  ))[3]	- ((__const unsigned char *)	(__const char *) (    "note"  ))[3]);	}	}	__result; })) 	: (__extension__ ({ __const unsigned char *__s1 =	(__const unsigned char *) (__const char *) (  d->incomm  );	register int __result =	__s1[0] - ((__const unsigned char *)	(__const char *) (    "note"  ))[0];	if (  __s2_len  > 0 && __result == 0)	{	__result = (__s1[1]	- ((__const unsigned char *)	(__const char *) (    "note"  ))[1]);	if (  __s2_len  > 1 && __result == 0)	{	__result =	(__s1[2] - ((__const unsigned char *)	(__const char *) (    "note"  ))[2]);	if (  __s2_len  > 2 && __result == 0)	__result =	(__s1[3]	- ((__const unsigned char *)	(__const char *) (    "note"  ))[3]);	}	}	__result; })) )	: strcmp ( d->incomm ,   "note" )))); })  )
				d->repeat--;
		}
	}
	
     


	if ( d->incomm[0] == '!' )
		str_cpy( d->incomm, d->inlast );
	else
		str_cpy( d->inlast, d->incomm );

	shift_buffer(d,i);	
return;
}

# 675 "comm.c"






void excessive_cpu(int blx)
{
	CHAR_DATA *vch;
	CHAR_DATA *vch_next;
	
	for ( vch = char_list; vch != ((void *)0) ; vch = vch_next )
	{
		vch_next = vch->next;
		
		if ( ! ((( ( vch )->act ) & (  1   )) )  )
		{
			send_to_char("Mud frozen: Autosave and quit.  Lurking Fear II will reboot in 2 seconds.\n\r",vch);
			interpret( vch, "quit" );
		}
	}
	abort();
}



void init_copyover_descriptor (DESCRIPTOR_DATA *dnew, int desc)
{
	 
	
	dnew = new_descriptor();	
	
	dnew->descriptor = desc;

	dnew->connected = 1 ;
	
}

void init_descriptor( int control )
{
	 
	DESCRIPTOR_DATA *dnew,*d = ((void *)0) ;
	struct sockaddr_in sock;
	struct hostent *from;
	int desc;
	int size;

	size = sizeof(sock);
	getsockname( control, (struct sockaddr *) &sock, &size );
	if ( ( desc = accept( control, (struct sockaddr *) &sock, &size) ) < 0 )
	{
		bug( "New_descriptor: accept",0 );
		return;
	}





	if ( fcntl( desc, 4 , 04000    ) == -1 )
	{
		bug( "New_descriptor: fcntl: FNDELAY",0 );
		return;
	}




	dnew = new_descriptor();	
	 

	dnew->descriptor = desc;

	dnew->connected  = 1 ;
	dnew->telnet_state = TOP_LEVEL;

	size = sizeof(sock);
	if ( getpeername( desc, (struct sockaddr *) &sock, &size ) < 0 )
	{
		bug( "New_descriptor: getpeername",0 );
		dnew->host = g_string_assign(d->host,"(unknown)");
	}
	else
	{
		 



		char *addr;

		addr = inet_ntoa(sock.sin_addr);
		 





		sprintf( log_buf, "Sock.sinaddr:  %s", addr );
		log_string2( log_buf );
		logchan(log_buf, ((void *)0) , ((void *)0) ,(8 ) ,0, (12  - 4) );

		 

		from = gethostbyaddr( (char *) &sock.sin_addr, sizeof(sock.sin_addr), 2   ); 
		if (!from)
			dnew->host = g_string_assign(dnew->host,addr);
		else
			dnew->host = g_string_assign(dnew->host,from->h_name);
	}
	 







	if ( check_ban(dnew->host,8  ))
	{
		write_to_descriptor(desc,"Your site has been banned from Lurking Fear II.\n\r",0);			
		write_to_descriptor(desc,"Someone has pissed us off, do not ask to lift the ban, \n\r",0);
		write_to_descriptor(desc,"Do not ask about the ban, do not bug us at all. Someone has\n\r",0);
		write_to_descriptor(desc,"Screwed you, I suggest find them and beat them to a pulp, because\n\r",0);
		write_to_descriptor(desc,"You WILL NOT CONNECT FROM THIS ISP. If you have caused the ban,\n\r",0);
		write_to_descriptor(desc,"YOU ARE NOT WELCOME HERE! FIND ANOTHER MUD AND GET LOST, YOU ARE HATED.\n\r",0);
		write_to_descriptor(desc,"You will only find your next ISP banned.\n\r",0);
		close( desc );
		free_descriptor(dnew);
		return;
	}

	 


	descriptor_list = g_slist_append(descriptor_list,dnew);

	 


	extern char * help_greeting;
	if ( help_greeting[0] == '.' )
		write_to_buffer( dnew, help_greeting+1, 0 );
	else
		write_to_buffer( dnew, help_greeting  , 0 );

	mudsetting->last_proc_logged = 3076;
	return;
}

 
void close_socket2( DESCRIPTOR_DATA *dclose, bool kickoff )
{
	CHAR_DATA *ch;
	
	if ( dclose->outbuf->len > 0 )
		process_output( dclose, (0)  );
	
	if (dclose->character != ((void *)0) )
		remove_snooper(dclose->character, dclose->character);

	if ( dclose->snoop_by != ((void *)0)  && g_slist_length(dclose->snoop_by) > 0)
		g_slist_free(dclose->snoop_by);

	if ( dclose->character != ((void *)0)  && dclose->connected == 9  &&
		((( ( dclose->character )->act ) & (  1   )) )  ) do_return(dclose->character,"");
 

















	
	if ( ( ch = dclose->character ) != ((void *)0)  )
	{
		if ( dclose->connected == 9  
			|| ((dclose->connected >= 11  )
				&& (dclose->connected <= 15 )))
		{
			if (kickoff)
				act( "$n doubles over in agony and $s eyes roll up into $s head.", ch, ((void *)0) , ((void *)0) , 0  );
			save_char_obj( ch );
			ch->desc = ((void *)0) ;
		}
	}
	
	descriptor_list = g_slist_remove(descriptor_list,dclose);

	close( dclose->descriptor );





	free_descriptor(dclose);	
	return;
}



bool read_from_descriptor( DESCRIPTOR_DATA *d )
{
	int iStart;
	
     
	if ( d->incomm[0] != '\0' )
		return (! (0) ) ;
	
     
	iStart = strlen(d->inbuf);
	if ( iStart >= sizeof(d->inbuf) - 10 )
	{
		if (d != ((void *)0)  && d->character != ((void *)0) )
			sprintf( log_buf, "%s input overflow!", d->character->lasthost->str );
		else
			sprintf( log_buf, "%s input overflow!", d->host->str );
		logchan(log_buf, ((void *)0) , ((void *)0) ,(524288 ) ,0, (12  - 4) );
		log_string2( log_buf );
		
		write_to_descriptor( d->descriptor,
			"\n\r*** SPAM is bad, Calm DOWN!!! ***\n\r", 0 );
		return (0) ;
	}
	
     
# 925 "comm.c"


# 955 "comm.c"

	

	for ( ; ; )
	{
		int nRead;
		
		nRead = read( d->descriptor, d->inbuf + iStart,
				sizeof(d->inbuf) - 10 - iStart );
		if ( nRead > 0 )
		{
			iStart += nRead;

			 
			 
		}
		else if ( nRead == 0 )
		{
			log_string2( "EOF encountered on read." );
			logchan(log_buf, ((void *)0) , ((void *)0) ,(524288 ) ,0, (12  - 4) );
			close_socket(d);
			return (0) ;
		}
		else if ( (*__errno_location ())  == 11   )
			break;
		else
		{
			bug( "Read_from_descriptor",0 );
			close_socket(d);
			return (0) ;
		}
	}

	
	d->inbuf[iStart] = '\0';
	return (! (0) ) ;
}






 


void nanny( DESCRIPTOR_DATA *d, char *argument )
{
	char buf[4096 ];
	char kav[4096 ];
	CHAR_DATA *ch;
	char *pwdnew;
	char *p;
	char *strtime;
	int char_age = 17;
	GSList	*desc_list;
	bool fOld,fDup = (0) ; 
	
	if (d->connected != 14 )
	{
		while ( (__ctype_b[(int) ( ( *argument ) )] & (unsigned short int)   _ISspace )   )
			argument++;
	}
	
	ch = d->character;
	
	
	switch ( d->connected )
	{

		default:
			bug( "Nanny: bad d->connected %d.", d->connected );
			close_socket( d );
			return;

		case 1 :
			if ( argument[0] == '\0' )
			{
				close_socket( d );
				return;
			}
			argument[0] = (( argument[0] ) >= 'a' && ( argument[0] ) <= 'z' ? ( argument[0] )+'A'-'a' : ( argument[0] )) ;
			if ( !check_parse_name( argument ) )
			{
				write_to_buffer( d, "Illegal name, try another.\n\r\n\rName: ", 0 );
				return;
			}


			sprintf(kav,"grep -iw %s bad.names > /dev/null", argument);

			if(0==system(kav)) 
			{
				write_to_buffer(d,"\n\rDictionary name check: This name is in dictionary.\n\r",0);
				write_to_buffer( d, "Illegal name, try another.\n\r\n\rName: ", 0 );
				return;
			}

			sprintf(kav,"%s trying to connect.", argument);
			log_string2( kav );
			fOld = load_char_short( d, argument );
			if (Player_Error == (! (0) ) )
			{
				Player_Error = (0) ;
				close_socket(d);
				return;
			}
			ch   = d->character;

			logchan(kav, ((void *)0) , ((void *)0) ,(4 ) ,0,ch->level );

			if ( (( ch->act ) & (  (1048576 )  ))  )
			{
				sprintf( log_buf, "Denying access to %s@%s.", argument, ch->lasthost->str );
				log_string2( log_buf );
				logchan(log_buf, ((void *)0) , ((void *)0) ,(4 ) ,0, (12  - 4) );
				write_to_buffer( d, "You are denied access to Lurking Fear II.  Have a nice day.\n\r", 0 );
				close_socket( d );

				return;
			}
			else if ( ((( ( ch )->extra ) & (  (  32768  ) )) )  && char_age < 15 )
			{
				char agebuf [160 ];
				if (char_age == 14)
					sprintf(agebuf, "You cannot play for another year.\n\r" );
				else
					sprintf(agebuf, "You cannot play for another %d years.\n\r", 
							(15 - years_old(ch)) );
				write_to_buffer(d, agebuf, 0);
				close_socket( d );
				return;
			}

			if (check_ban(d->host,16  ) && ! (( ch->act ) & ( (4 )  )) )
			{
				write_to_buffer(d,"Your site has been banned from Lurking Fear II.  Have a nice day.\n\r",0);			
				close_socket(d);
				return;
			}

			if ( check_reconnect( d, argument, (0)  ) )
			{
				fOld = (! (0) ) ;
			}
			else
			{
				 

				DESCRIPTOR_DATA *dcheck_next;
				int countdesc = 0;
				int max_players = 150;

				for ( desc_list = descriptor_list; desc_list != ((void *)0) ; desc_list = (( desc_list ) ? (((GSList *)( desc_list ))->next) : ((void *)0) )  )
				{
					dcheck_next = desc_list->data;
					countdesc++;
				}

				 
				if ( countdesc > max_players && ! (get_trust( ch ) >= (12  - 5) )  )
				{
					write_to_buffer( d, "Too many players connected, please try again in a couple of minutes.\n\r", 0 );
					close_socket( d );
					return;
				}

				if ( wizlock && ! (get_trust( ch ) >= (12  - 5) )  )
				{
					write_to_buffer( d, "Lurking Fear II is temporarily BROKEN.  Please try again later.\n\r", 0 );
					close_socket( d );
					return;
				}
			}

			if ( fOld )
			{
				 
				send_reply(d,251 ,1 );
				 
				write_to_buffer( d, "Please enter password: ", 0 );

				d->connected = 2 ;
				return;
			}
			else
			{

				 
				if ( check_newbie_playing(d, argument ) )
				{
					write_to_buffer(d, "There is someone already on with that name. Please choose another!.\n\rName: ",0);
					return;
				}

				if (newlock)
				{
					write_to_buffer( d, "Lurking Fear II is temporarily newlocked.  Please try again later.\n\r", 0 );
					close_socket( d );
					return;
				}

				if (check_ban(d->host,4  ))
				{
					write_to_buffer(d,"New players are not allowed on Lurking Fear II from your site.\n\r",0);
					close_socket(d);
					return;
				}

				do_help (ch, " newname");
				sprintf( buf, "You want %s engraved on your tombstone (Y/N)? ", argument );
				write_to_buffer( d, buf, 0 );
				d->connected = 3 ;
				return;
			}
			break;

		case 2 :

			write_to_buffer( d, "\n\r", 2 );



			if ( ch == ((void *)0)  || (! ((( ( ch )->extra ) & (  ( 8  ) )) )  &&
						(ch->pcdata->pwd->len > 0 &&
						(__extension__	({ size_t __s1_len, __s2_len;	(__builtin_constant_p (  argument ) && __builtin_constant_p (  ch->pcdata->pwd->str  )	&& (__s1_len = strlen (  argument ), __s2_len = strlen (  ch->pcdata->pwd->str  ),	(! ((size_t)(const void *)((   argument  ) + 1) - (size_t)(const void *)(   argument  ) == 1)  || __s1_len >= 4)	&& (! ((size_t)(const void *)((   ch->pcdata->pwd->str   ) + 1) - (size_t)(const void *)(   ch->pcdata->pwd->str   ) == 1)  || __s2_len >= 4))	? memcmp ((__const char *) (  argument ), (__const char *) (  ch->pcdata->pwd->str  ),	(__s1_len < __s2_len ? __s1_len : __s2_len) + 1)	: (__builtin_constant_p (  argument ) && ((size_t)(const void *)((   argument  ) + 1) - (size_t)(const void *)(   argument  ) == 1) 	&& (__s1_len = strlen (  argument ), __s1_len < 4)	? (__builtin_constant_p (  ch->pcdata->pwd->str  ) && ((size_t)(const void *)((   ch->pcdata->pwd->str   ) + 1) - (size_t)(const void *)(   ch->pcdata->pwd->str   ) == 1) 	? (__extension__ ({ register int __result =	(((__const unsigned char *) (__const char *) (   argument  ))[0] - ((__const unsigned char *) (__const char *)(    ch->pcdata->pwd->str   ))[0]);	if (  __s1_len  > 0 && __result == 0)	{	__result = (((__const unsigned char *)	(__const char *) (   argument  ))[1]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[1]);	if (  __s1_len  > 1 && __result == 0)	{	__result =	(((__const unsigned char *)	(__const char *) (   argument  ))[2]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[2]);	if (  __s1_len  > 2 && __result == 0)	__result =	(((__const unsigned char *)	(__const char *) (   argument  ))[3]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[3]);	}	}	__result; })) 	: (__extension__ ({ __const unsigned char *__s2 =	(__const unsigned char *) (__const char *) (    ch->pcdata->pwd->str   );	register int __result =	(((__const unsigned char *) (__const char *) (   argument  ))[0] - __s2[0]);	if (  __s1_len  > 0 && __result == 0)	{	__result = (((__const unsigned char *)	(__const char *) (   argument  ))[1] - __s2[1]); if (  __s1_len  > 1 && __result == 0)	{	__result = (((__const unsigned char *)	(__const char *) (   argument  ))[2] - __s2[2]);	if (  __s1_len  > 2 && __result == 0)	__result = (((__const unsigned char *)	(__const char *)  (   argument  ))[3]	- __s2[3]);	}	}	__result; })) )	: (__builtin_constant_p (  ch->pcdata->pwd->str  ) && ((size_t)(const void *)((   ch->pcdata->pwd->str   ) + 1) - (size_t)(const void *)(   ch->pcdata->pwd->str   ) == 1) 	&& (__s2_len = strlen (  ch->pcdata->pwd->str  ), __s2_len < 4)	? (__builtin_constant_p (  argument ) && ((size_t)(const void *)((   argument  ) + 1) - (size_t)(const void *)(   argument  ) == 1) 	? (__extension__ ({ register int __result =	(((__const unsigned char *) (__const char *) (   argument  ))[0] - ((__const unsigned char *) (__const char *)(    ch->pcdata->pwd->str   ))[0]);	if (  __s2_len  > 0 && __result == 0)	{	__result = (((__const unsigned char *)	(__const char *) (   argument  ))[1]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[1]);	if (  __s2_len  > 1 && __result == 0)	{	__result =	(((__const unsigned char *)	(__const char *) (   argument  ))[2]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[2]);	if (  __s2_len  > 2 && __result == 0)	__result =	(((__const unsigned char *)	(__const char *) (   argument  ))[3]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[3]);	}	}	__result; })) 	: (__extension__ ({ __const unsigned char *__s1 =	(__const unsigned char *) (__const char *) (   argument  );	register int __result =	__s1[0] - ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[0];	if (  __s2_len  > 0 && __result == 0)	{	__result = (__s1[1]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[1]);	if (  __s2_len  > 1 && __result == 0)	{	__result =	(__s1[2] - ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[2]);	if (  __s2_len  > 2 && __result == 0)	__result =	(__s1[3]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[3]);	}	}	__result; })) )	: strcmp (  argument ,   ch->pcdata->pwd->str  )))); })  &&
						__extension__	({ size_t __s1_len, __s2_len;	(__builtin_constant_p (  crypt( argument, ch->pcdata->pwd->str ) ) && __builtin_constant_p (  ch->pcdata->pwd->str  )	&& (__s1_len = strlen (  crypt( argument, ch->pcdata->pwd->str ) ), __s2_len = strlen (  ch->pcdata->pwd->str  ),	(! ((size_t)(const void *)((   crypt( argument, ch->pcdata->pwd->str )  ) + 1) - (size_t)(const void *)(   crypt( argument, ch->pcdata->pwd->str )  ) == 1)  || __s1_len >= 4)	&& (! ((size_t)(const void *)((   ch->pcdata->pwd->str   ) + 1) - (size_t)(const void *)(   ch->pcdata->pwd->str   ) == 1)  || __s2_len >= 4))	? memcmp ((__const char *) (  crypt( argument, ch->pcdata->pwd->str ) ), (__const char *) (  ch->pcdata->pwd->str  ),	(__s1_len < __s2_len ? __s1_len : __s2_len) + 1)	: (__builtin_constant_p (  crypt( argument, ch->pcdata->pwd->str ) ) && ((size_t)(const void *)((   crypt( argument, ch->pcdata->pwd->str )  ) + 1) - (size_t)(const void *)(   crypt( argument, ch->pcdata->pwd->str )  ) == 1) 	&& (__s1_len = strlen (  crypt( argument, ch->pcdata->pwd->str ) ), __s1_len < 4)	? (__builtin_constant_p (  ch->pcdata->pwd->str  ) && ((size_t)(const void *)((   ch->pcdata->pwd->str   ) + 1) - (size_t)(const void *)(   ch->pcdata->pwd->str   ) == 1) 	? (__extension__ ({ register int __result =	(((__const unsigned char *) (__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[0] - ((__const unsigned char *) (__const char *)(    ch->pcdata->pwd->str   ))[0]);	if (  __s1_len  > 0 && __result == 0)	{	__result = (((__const unsigned char *)	(__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[1]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[1]);	if (  __s1_len  > 1 && __result == 0)	{	__result =	(((__const unsigned char *)	(__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[2]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[2]);	if (  __s1_len  > 2 && __result == 0)	__result =	(((__const unsigned char *)	(__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[3]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[3]);	}	}	__result; })) 	: (__extension__ ({ __const unsigned char *__s2 =	(__const unsigned char *) (__const char *) (    ch->pcdata->pwd->str   );	register int __result =	(((__const unsigned char *) (__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[0] - __s2[0]);	if (  __s1_len  > 0 && __result == 0)	{	__result = (((__const unsigned char *)	(__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[1] - __s2[1]); if (  __s1_len  > 1 && __result == 0)	{	__result = (((__const unsigned char *)	(__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[2] - __s2[2]);	if (  __s1_len  > 2 && __result == 0)	__result = (((__const unsigned char *)	(__const char *)  (   crypt( argument, ch->pcdata->pwd->str )  ))[3]	- __s2[3]);	}	}	__result; })) )	: (__builtin_constant_p (  ch->pcdata->pwd->str  ) && ((size_t)(const void *)((   ch->pcdata->pwd->str   ) + 1) - (size_t)(const void *)(   ch->pcdata->pwd->str   ) == 1) 	&& (__s2_len = strlen (  ch->pcdata->pwd->str  ), __s2_len < 4)	? (__builtin_constant_p (  crypt( argument, ch->pcdata->pwd->str ) ) && ((size_t)(const void *)((   crypt( argument, ch->pcdata->pwd->str )  ) + 1) - (size_t)(const void *)(   crypt( argument, ch->pcdata->pwd->str )  ) == 1) 	? (__extension__ ({ register int __result =	(((__const unsigned char *) (__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[0] - ((__const unsigned char *) (__const char *)(    ch->pcdata->pwd->str   ))[0]);	if (  __s2_len  > 0 && __result == 0)	{	__result = (((__const unsigned char *)	(__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[1]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[1]);	if (  __s2_len  > 1 && __result == 0)	{	__result =	(((__const unsigned char *)	(__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[2]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[2]);	if (  __s2_len  > 2 && __result == 0)	__result =	(((__const unsigned char *)	(__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[3]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[3]);	}	}	__result; })) 	: (__extension__ ({ __const unsigned char *__s1 =	(__const unsigned char *) (__const char *) (   crypt( argument, ch->pcdata->pwd->str )  );	register int __result =	__s1[0] - ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[0];	if (  __s2_len  > 0 && __result == 0)	{	__result = (__s1[1]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[1]);	if (  __s2_len  > 1 && __result == 0)	{	__result =	(__s1[2] - ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[2]);	if (  __s2_len  > 2 && __result == 0)	__result =	(__s1[3]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[3]);	}	}	__result; })) )	: strcmp (  crypt( argument, ch->pcdata->pwd->str ) ,   ch->pcdata->pwd->str  )))); }) ))))
			{
				write_to_buffer( d, "Wrong password.\n\r", 0 );
				free_char( ch );
				close_socket( d );
				return;
			}
			else if ( ch == ((void *)0)  || (((( ( ch )->extra ) & (  ( 8  ) )) )  &&
						(ch->pcdata->pwd->len > 0 &&
						(__extension__	({ size_t __s1_len, __s2_len;	(__builtin_constant_p (  crypt( argument, ch->pcdata->pwd->str ) ) && __builtin_constant_p (  ch->pcdata->pwd->str  )	&& (__s1_len = strlen (  crypt( argument, ch->pcdata->pwd->str ) ), __s2_len = strlen (  ch->pcdata->pwd->str  ),	(! ((size_t)(const void *)((   crypt( argument, ch->pcdata->pwd->str )  ) + 1) - (size_t)(const void *)(   crypt( argument, ch->pcdata->pwd->str )  ) == 1)  || __s1_len >= 4)	&& (! ((size_t)(const void *)((   ch->pcdata->pwd->str   ) + 1) - (size_t)(const void *)(   ch->pcdata->pwd->str   ) == 1)  || __s2_len >= 4))	? memcmp ((__const char *) (  crypt( argument, ch->pcdata->pwd->str ) ), (__const char *) (  ch->pcdata->pwd->str  ),	(__s1_len < __s2_len ? __s1_len : __s2_len) + 1)	: (__builtin_constant_p (  crypt( argument, ch->pcdata->pwd->str ) ) && ((size_t)(const void *)((   crypt( argument, ch->pcdata->pwd->str )  ) + 1) - (size_t)(const void *)(   crypt( argument, ch->pcdata->pwd->str )  ) == 1) 	&& (__s1_len = strlen (  crypt( argument, ch->pcdata->pwd->str ) ), __s1_len < 4)	? (__builtin_constant_p (  ch->pcdata->pwd->str  ) && ((size_t)(const void *)((   ch->pcdata->pwd->str   ) + 1) - (size_t)(const void *)(   ch->pcdata->pwd->str   ) == 1) 	? (__extension__ ({ register int __result =	(((__const unsigned char *) (__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[0] - ((__const unsigned char *) (__const char *)(    ch->pcdata->pwd->str   ))[0]);	if (  __s1_len  > 0 && __result == 0)	{	__result = (((__const unsigned char *)	(__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[1]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[1]);	if (  __s1_len  > 1 && __result == 0)	{	__result =	(((__const unsigned char *)	(__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[2]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[2]);	if (  __s1_len  > 2 && __result == 0)	__result =	(((__const unsigned char *)	(__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[3]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[3]);	}	}	__result; })) 	: (__extension__ ({ __const unsigned char *__s2 =	(__const unsigned char *) (__const char *) (    ch->pcdata->pwd->str   );	register int __result =	(((__const unsigned char *) (__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[0] - __s2[0]);	if (  __s1_len  > 0 && __result == 0)	{	__result = (((__const unsigned char *)	(__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[1] - __s2[1]); if (  __s1_len  > 1 && __result == 0)	{	__result = (((__const unsigned char *)	(__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[2] - __s2[2]);	if (  __s1_len  > 2 && __result == 0)	__result = (((__const unsigned char *)	(__const char *)  (   crypt( argument, ch->pcdata->pwd->str )  ))[3]	- __s2[3]);	}	}	__result; })) )	: (__builtin_constant_p (  ch->pcdata->pwd->str  ) && ((size_t)(const void *)((   ch->pcdata->pwd->str   ) + 1) - (size_t)(const void *)(   ch->pcdata->pwd->str   ) == 1) 	&& (__s2_len = strlen (  ch->pcdata->pwd->str  ), __s2_len < 4)	? (__builtin_constant_p (  crypt( argument, ch->pcdata->pwd->str ) ) && ((size_t)(const void *)((   crypt( argument, ch->pcdata->pwd->str )  ) + 1) - (size_t)(const void *)(   crypt( argument, ch->pcdata->pwd->str )  ) == 1) 	? (__extension__ ({ register int __result =	(((__const unsigned char *) (__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[0] - ((__const unsigned char *) (__const char *)(    ch->pcdata->pwd->str   ))[0]);	if (  __s2_len  > 0 && __result == 0)	{	__result = (((__const unsigned char *)	(__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[1]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[1]);	if (  __s2_len  > 1 && __result == 0)	{	__result =	(((__const unsigned char *)	(__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[2]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[2]);	if (  __s2_len  > 2 && __result == 0)	__result =	(((__const unsigned char *)	(__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[3]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[3]);	}	}	__result; })) 	: (__extension__ ({ __const unsigned char *__s1 =	(__const unsigned char *) (__const char *) (   crypt( argument, ch->pcdata->pwd->str )  );	register int __result =	__s1[0] - ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[0];	if (  __s2_len  > 0 && __result == 0)	{	__result = (__s1[1]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[1]);	if (  __s2_len  > 1 && __result == 0)	{	__result =	(__s1[2] - ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[2]);	if (  __s2_len  > 2 && __result == 0)	__result =	(__s1[3]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[3]);	}	}	__result; })) )	: strcmp (  crypt( argument, ch->pcdata->pwd->str ) ,   ch->pcdata->pwd->str  )))); }) ))))
			{
				write_to_buffer( d, "Wrong password.\n\r", 0 );
				free_char( ch );
				close_socket( d );
				return;
			}

			 
			send_reply(d,252 ,1 );

			if ( check_reconnect( d, ch->name->str, (! (0) )  ) )
			{
				fDup = (! (0) ) ;
				return;
			}

			if ( check_playing( d, ch->name->str ) )
			{
				fDup = (! (0) ) ;
				return;
			}

			if ( check_kickoff( d, ch->name->str, (0)  ) )
			{
				fDup = (! (0) ) ;
				return;
			}

			if ( check_player_ID( d, ch->name->str, (0)  ) )
			{
				fDup = (! (0) ) ;
				return;
			}
			 
			if (ch->level > 1)
			{
				sprintf(kav,ch->name->str);
				 
				 
				 








				ch   = d->character;
				fOld = (! (0) ) ;
				 












			}

			if ( ! ((( ( ch )->extra ) & (  ( 8  ) )) )  && strlen(argument) > 1) {
				sprintf(kav,"%s %s",argument,argument);
				do_password(ch,kav);}

				if ((get_trust( ch ) >= (12  - 5) ) )
					sprintf( log_buf, "{W%s@%s has connected.{x", ch->name->str, ch->lasthost->str );
				else
					sprintf( log_buf, "%s@%s has connected.", ch->name->str, ch->lasthost->str );

				log_string2( log_buf );
				logchan(log_buf, ((void *)0) , ((void *)0) ,(4 ) ,0,ch->level );

				 


				if ( ch->level > 3 && ch->trust == 0)
					ch->level = 3;
				else
				{
					if ( ch->level > 12  )
						ch->level = 12 ;
					if ( ch->trust > 12 )
						ch->trust = 12 ;
					 



				}
				if (d->character->level == (12  - 9) )
				{
					d->connected = 17 ;
					send_to_char("Press RETURN to continue:\n\r",d->character);
				}
				else
				{
					if ( (get_trust( ch ) >= (12  - 9) )  )
						do_help( ch, "imotd" );
					do_help( ch, "motd" );
					d->connected = 8 ;
				}
				break;

		case 17 :

				if ( (get_trust( ch ) >= (12  - 9) )  )
					do_help( ch, "imotd" );
				do_help( ch, "motd" );
				d->connected = 8 ;
				break;

		case 3 :
				switch ( *argument )
				{
					case 'y': case 'Y':
						sprintf( buf, "New character.\n\rGive me a password for %s: ",
								ch->name->str );
						write_to_buffer( d, buf, 0 );
						d->connected = 4 ;
						break;

					case 'n': case 'N':
						write_to_buffer( d, "Ok, what IS it, then? ", 0 );
						free_char( d->character );
						d->character = ((void *)0) ;
						d->connected = 1 ;
						break;

					default:
						write_to_buffer( d, "Please type Yes or No? ", 0 );
						break;
				}
				break;

		case 4 :

				write_to_buffer( d, "\n\r", 2 );


				if ( strlen(argument) < 5 )
				{
					write_to_buffer( d,
							"Password must be at least five characters long.\n\rPassword: ",
							0 );
					return;
				}


				pwdnew = crypt( argument, ch->name->str );




				for ( p = pwdnew; *p != '\0'; p++ )
				{
					if ( *p == '~' )
					{
						write_to_buffer( d,
								"New password not acceptable, try again.\n\rPassword: ",
								0 );
						return;
					}
				}

				ch->pcdata->pwd	= g_string_assign(ch->pcdata->pwd, pwdnew );

				write_to_buffer( d, "Please retype password: ", 0 );
				d->connected = 5 ;
				break;

		case 5 :

				write_to_buffer( d, "\n\r", 2 );

				if ( __extension__	({ size_t __s1_len, __s2_len;	(__builtin_constant_p (  crypt( argument, ch->pcdata->pwd->str ) ) && __builtin_constant_p (  ch->pcdata->pwd->str  )	&& (__s1_len = strlen (  crypt( argument, ch->pcdata->pwd->str ) ), __s2_len = strlen (  ch->pcdata->pwd->str  ),	(! ((size_t)(const void *)((   crypt( argument, ch->pcdata->pwd->str )  ) + 1) - (size_t)(const void *)(   crypt( argument, ch->pcdata->pwd->str )  ) == 1)  || __s1_len >= 4)	&& (! ((size_t)(const void *)((   ch->pcdata->pwd->str   ) + 1) - (size_t)(const void *)(   ch->pcdata->pwd->str   ) == 1)  || __s2_len >= 4))	? memcmp ((__const char *) (  crypt( argument, ch->pcdata->pwd->str ) ), (__const char *) (  ch->pcdata->pwd->str  ),	(__s1_len < __s2_len ? __s1_len : __s2_len) + 1)	: (__builtin_constant_p (  crypt( argument, ch->pcdata->pwd->str ) ) && ((size_t)(const void *)((   crypt( argument, ch->pcdata->pwd->str )  ) + 1) - (size_t)(const void *)(   crypt( argument, ch->pcdata->pwd->str )  ) == 1) 	&& (__s1_len = strlen (  crypt( argument, ch->pcdata->pwd->str ) ), __s1_len < 4)	? (__builtin_constant_p (  ch->pcdata->pwd->str  ) && ((size_t)(const void *)((   ch->pcdata->pwd->str   ) + 1) - (size_t)(const void *)(   ch->pcdata->pwd->str   ) == 1) 	? (__extension__ ({ register int __result =	(((__const unsigned char *) (__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[0] - ((__const unsigned char *) (__const char *)(    ch->pcdata->pwd->str   ))[0]);	if (  __s1_len  > 0 && __result == 0)	{	__result = (((__const unsigned char *)	(__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[1]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[1]);	if (  __s1_len  > 1 && __result == 0)	{	__result =	(((__const unsigned char *)	(__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[2]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[2]);	if (  __s1_len  > 2 && __result == 0)	__result =	(((__const unsigned char *)	(__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[3]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[3]);	}	}	__result; })) 	: (__extension__ ({ __const unsigned char *__s2 =	(__const unsigned char *) (__const char *) (    ch->pcdata->pwd->str   );	register int __result =	(((__const unsigned char *) (__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[0] - __s2[0]);	if (  __s1_len  > 0 && __result == 0)	{	__result = (((__const unsigned char *)	(__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[1] - __s2[1]); if (  __s1_len  > 1 && __result == 0)	{	__result = (((__const unsigned char *)	(__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[2] - __s2[2]);	if (  __s1_len  > 2 && __result == 0)	__result = (((__const unsigned char *)	(__const char *)  (   crypt( argument, ch->pcdata->pwd->str )  ))[3]	- __s2[3]);	}	}	__result; })) )	: (__builtin_constant_p (  ch->pcdata->pwd->str  ) && ((size_t)(const void *)((   ch->pcdata->pwd->str   ) + 1) - (size_t)(const void *)(   ch->pcdata->pwd->str   ) == 1) 	&& (__s2_len = strlen (  ch->pcdata->pwd->str  ), __s2_len < 4)	? (__builtin_constant_p (  crypt( argument, ch->pcdata->pwd->str ) ) && ((size_t)(const void *)((   crypt( argument, ch->pcdata->pwd->str )  ) + 1) - (size_t)(const void *)(   crypt( argument, ch->pcdata->pwd->str )  ) == 1) 	? (__extension__ ({ register int __result =	(((__const unsigned char *) (__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[0] - ((__const unsigned char *) (__const char *)(    ch->pcdata->pwd->str   ))[0]);	if (  __s2_len  > 0 && __result == 0)	{	__result = (((__const unsigned char *)	(__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[1]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[1]);	if (  __s2_len  > 1 && __result == 0)	{	__result =	(((__const unsigned char *)	(__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[2]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[2]);	if (  __s2_len  > 2 && __result == 0)	__result =	(((__const unsigned char *)	(__const char *) (   crypt( argument, ch->pcdata->pwd->str )  ))[3]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[3]);	}	}	__result; })) 	: (__extension__ ({ __const unsigned char *__s1 =	(__const unsigned char *) (__const char *) (   crypt( argument, ch->pcdata->pwd->str )  );	register int __result =	__s1[0] - ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[0];	if (  __s2_len  > 0 && __result == 0)	{	__result = (__s1[1]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[1]);	if (  __s2_len  > 1 && __result == 0)	{	__result =	(__s1[2] - ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[2]);	if (  __s2_len  > 2 && __result == 0)	__result =	(__s1[3]	- ((__const unsigned char *)	(__const char *) (    ch->pcdata->pwd->str   ))[3]);	}	}	__result; })) )	: strcmp (  crypt( argument, ch->pcdata->pwd->str ) ,   ch->pcdata->pwd->str  )))); })  )
				{
					write_to_buffer( d, "Passwords don't match.\n\rRetype password: ",
							0 );
					d->connected = 4 ;
					return;
				}

				 
				send_reply(d,252 ,1 );
				
				write_to_buffer( d, "What is your sex (M/F)? ", 0 );
				d->connected = 6 ;
				break;

		case 6 :
				switch ( argument[0] )
				{
					case 'm': case 'M': ch->sex = 1 ;    break;
					case 'f': case 'F': ch->sex = 2 ;  break;
					default:
							    write_to_buffer( d, "That's not a sex.\n\rWhat IS your sex? ", 0 );
							    return;
				}
				 



	
				 


				ch->pcdata->perm_str=number_range(10,16);
				ch->pcdata->perm_int=number_range(10,16);
				ch->pcdata->perm_wis=number_range(10,16);
				ch->pcdata->perm_dex=number_range(10,16);
				ch->pcdata->perm_con=number_range(10,16);
				sprintf( log_buf, "%s@%s new player.", ch->name->str, d->host->str );
				log_string2( log_buf );
				logchan(log_buf, ((void *)0) , ((void *)0) ,(131072 ) ,0, (12  - 4) );
				write_to_buffer( d, "\n\r", 2 );
				do_help( ch, "motd" );
				d->connected = 8 ;

				break;

		case 11 :
				handle_con_note_to (d, argument);
				break;

		case 12 :
				handle_con_note_subject (d, argument);
				break;  

		case 13 :
				handle_con_note_expire (d, argument);
				break;

		case 14 :
				handle_con_note_text (d, argument);
				break;

		case 15 :
				handle_con_note_finish (d, argument);
				break;

		case 8 :
				write_to_buffer( d,     "\n\rWelcome to Lurking Fear II.  Don't be afraid of the dark.\n\r\n\r",
						0 );
				 

				if (ch->level > 1)
				{
					if (!fDup) 
					{
						 



						char *tmpname = g_strdup(ch->name->str);

						free_char(ch);
						free_char(d->character);

						d->character = ((void *)0) ;
						ch = ((void *)0) ;

						fOld = load_char_obj( d, tmpname );
						g_free(tmpname);
						if (Player_Error == (! (0) ) )
						{
							Player_Error = (0) ;
							close_socket(d);
							return;
						}
						ch = d->character;

						if ( fOld && ch->lasthost != ((void *)0)  && ch->lasthost->len > 1 &&
								ch->lasttime != ((void *)0)  && ch->lasttime->len)
						{
							sprintf(kav,"Last connected from %s at %s\n\r",ch->lasthost->str,ch->lasttime->str);
							write_to_buffer( d, kav, 0 );
						}
						else if ( fOld && ch->lasthost != ((void *)0)  && ch->lasthost->len)
						{
							sprintf(kav,"Last connected from %s.\n\r",ch->lasthost->str);
							write_to_buffer( d, kav, 0 );
						}
					}
				}

				if (!fDup) 
				{
					ch->next	= char_list;
					char_list	= ch;
				}

				d->connected	= 9 ;

				if (ch->desc != ((void *)0)  && ch->desc->host != ((void *)0) )
				{
					ch->lasthost = g_string_assign(ch->lasthost, ch->desc->host->str);
				}
				else
					ch->lasthost = g_string_assign(ch->lasthost,"(unknown)");
				strtime = ctime( &current_time );
				strtime[strlen(strtime)-1] = '\0';
				ch->lasttime = g_string_assign(ch->lasttime,strtime );

				 

				if ((get_trust( ch ) >= 3 && get_trust( ch ) <= 6) )
				{
					do_help(ch,"wait timer");
					ch->delay_timer = 6;
				}

				if (((( ( ch )->class ) & (    (8 )   )) )  && ch->level < 4  ) 
				{
					int ch_age = (get_age(ch) - 17) * 2;   
					ch->pcdata->rank = 1 ;

					if      (ch_age >= 1500) ch->pcdata->rank = 4 ;
					else if (ch_age >=  800) ch->pcdata->rank = 3 ;
					else if (ch_age >=  400) ch->pcdata->rank = 2 ;
					else if (ch_age >=  200) ch->pcdata->rank = 1 ;
					else                     ch->pcdata->rank = 0 ;
				}

				if ( ch->level == 0 )
				{
					ch->level	= 1;
					ch->exp	        = 100;
					ch->hit	        = ch->max_hit;
					ch->mana	= ch->max_mana;
					ch->move	= ch->max_move;
					ch->class       = 0;
					ch->special     = 0;
					ch->gold        = 500;
					ch->pcdata->charpoints	= 20;
					set_title( ch, "the newbie mortal" );

					(( ch->act ) |= (  (8 )  )) ;
					ch->short_descr = g_string_assign(ch->short_descr,"");
					ch->long_descr = g_string_assign(ch->long_descr,"");
					ch->description = g_string_assign(ch->description,"");
					(( ch->deaf ) &= ~(  262144   )) ;
					(( ch->deaf ) &= ~(  524288   )) ;
					(( ch->deaf ) &= ~(  16   )) ;

					if ((( mudsetting->mud_setting ) & (  (1 )  )) )
					{
						send_to_char("--------------------------------------------------------------------------------\n\r",ch);
						send_to_char("Welcome to Class Balancing Night! You are set with HP/MANA/PRIMAL, go bug a Imm \n\r",ch);
						send_to_char("about getting classed and have fun! Remember this is only to balance classes and\n\r",ch);
						send_to_char("all the original characters will be back to normal.\n\r",ch);
						send_to_char("--------------------------------------------------------------------------------\n\r\n\r",ch);
					}
					else
					{
						send_to_char("--------------------------------------------------------------------------------\n\r",ch);
						send_to_char("If you need help, try talking to the spirit of mud school!\n\r",ch);
						send_to_char("--------------------------------------------------------------------------------\n\r\n\r",ch);
						do_help (ch, "newstart");
					}
					char_to_room( ch, get_room_index( 3700  ) );
					do_look( ch, "auto" );
					if ((( mudsetting->mud_setting ) & (  (1 )  )) )
					{
						ch->hit = 50000;
						ch->mana = 50000;
						ch->move = 50000;
						ch->practice = 8000;
						ch->race = 1;
						ch->level = 3;
						ch->exp = 900000;
						set_title( ch, "the newbie avatar" );
					}
				}
				else if (! ((( ( ch )->act ) & (  1   )) )  && ch->pcdata->obj_vnum != 0)
				{
					if (ch->in_room != ((void *)0) ) char_to_room( ch, ch->in_room );
					else char_to_room( ch, get_room_index( 3700  ) );
					bind_char(ch);
					break;
				}
				else if ( ch->in_room != ((void *)0)  )
				{
					char_to_room( ch, ch->in_room );
					do_look( ch, "auto" );
				}
				else if ( (get_trust( ch ) >= (12  - 5) )  )
				{
					char_to_room( ch, get_room_index( 1200  ) );
					do_look( ch, "auto" );
				}
				else
				{
					char_to_room( ch, get_room_index( 3001  ) );
					do_look( ch, "auto" );
				}
				 
				 

				 







				 

				if (! ((( ( ch )->immune ) & (  ( 4096     ) )) ) )  
					(( ch->immune ) |= (  4096   )) ;
				if (! ((( ( ch )->immune ) & (  ( 67108864    ) )) ) )  
					(( ch->immune ) |= (  67108864   )) ;
				if (! ((( ( ch )->immune ) & (  ( 8388608        ) )) ) )  
					(( ch->immune ) |= (  8388608      )) ;

				 
				if ( (( ch->deaf ) & (  262144    )) )
				{
					int midnum;
					midnum = number_range( 0, 9  );
					 
					sprintf(buf,"\n\r!!MUSIC(%s T=music L=1 V=100 U=http://%s%s )\n\r",msp_midi_table[midnum].msp_string, msp_midi_table[midnum].msp_server, msp_midi_table[midnum].msp_dirinfo);
					write_to_buffer(d,buf,0);
				}
				 
				if ((get_trust( ch ) == 3) )
					ch->pcdata->followers = check_follower_count(ch);

				 		
				if (((( ( ch )->class ) & (   (64 )   )) ) )
					ch->pcdata->gnosis = (get_hours(ch) / 100);	
				act( "$n has entered the realm.", ch, ((void *)0) , ((void *)0) , 0  );
				do_board(ch, "");
				room_text(ch,">ENTER<");
				 
				break;
	}
	
	mudsetting->last_proc_logged = 23;
	
	return;
}



 


bool check_parse_name( char *name )
{
     


	 
	if ( is_name( name," all auto immortal imm self someone gaia kavir rotain arkyn amoeba smokey admin guest user caine lilith abel absimilard veddartha zillah irad enoch haquim saulot ennoia arikel ashur sutekh troile camarilla sabbat inconnu assamite brujah cappadocian set gangrel lasombra malkav nosferatu ravnos toreador tremere tzimisce ventrue baali caitiff kaine cain kain followers set malkavian fianna fenris get silver fangs shadow lords bone gnawers ronin silverfang shadowlord bonegnawer akashic cult ecstasy cultecstasy cultofecstasy dreamspeakers order hermes orderhermes orderofhermes verbena sonsofether pheonix pheonixx phoenix strom maelstrom nimufu artemis jasmine belgerion blizzard loco unlinked" ) )
		return (0) ;
	
         
	if ( !str_suffix("Sux",name) || !str_suffix("Sucks",name)
		|| !str_prefix("Suck",name) || !str_prefix("Vamp",name)  
		|| !str_prefix("Shit",name) || !str_suffix("shit",name)
		|| !str_prefix("Ass",name)  || !str_suffix("ass",name)
		|| !str_prefix("Imp",name)  || !str_suffix("imp",name)
		|| !str_prefix("Impl",name) || !str_suffix("impl",name)
		|| !str_prefix("Girl",name) || !str_suffix("girl",name)
		|| !str_prefix("Boy",name)  || !str_suffix("boy",name)
		|| !str_suffix("man",name)  || !str_suffix("woman",name)
		|| !str_prefix("Fuck",name) || !str_suffix("fuck",name)
		|| !str_suffix("z",name)
		)
		return (0) ;               
	
	if ((str_cmp(capitalize(name),"Immortal"))
		&& (!str_suffix("Immortal",name) || !str_prefix("Imm",name)))
		return (0) ;
	
	if ((str_cmp(capitalize(name),"Caine"))
		&& (!str_suffix("Caine",name) || !str_prefix("Caine",name)))
		return (0) ;
	
	if ((str_cmp(capitalize(name),"Dominion"))
		&& (!str_suffix("Dominion",name) || !str_prefix("Dom",name)))
		return (0) ;
	
	if ((str_cmp(capitalize(name),"Jovie")) 
		&& (!str_suffix("Jovie",name)))
		return (0) ;
	
	if ((str_cmp(capitalize(name),"Spiral"))
		&& (!str_suffix("Spiral",name) || !str_prefix("Spiral",name)))  
		return (0) ;
	
	if ((str_cmp(capitalize(name),"Macabre"))
		&& (!str_suffix("Macabre",name) || !str_prefix("Macabre",name)))  
		return (0) ;
	
	if ((str_cmp(capitalize(name),"Viscera"))
		&& (!str_suffix("Viscera",name) || !str_prefix("Viscera",name)))  
		return (0) ;
	
     


	if ( strlen(name) <  3 )
		return (0) ;
	




	

	if ( strlen(name) > 12 )
		return (0) ;

	
     



	{
		char *pc;
		bool fIll, adjcaps = (0) , cleancaps = (0) ;
		int total_caps = 0;
		
		fIll = (! (0) ) ;
		for ( pc = name; *pc != '\0'; pc++ )
		{
			if ( ! (__ctype_b[(int) ( ( *pc ) )] & (unsigned short int)   _ISalpha )   )
				return (0) ;
			
			if ( (__ctype_b[(int) ( ( *pc ) )] & (unsigned short int)   _ISupper )  )  
			{
				if (adjcaps)
					cleancaps = (! (0) ) ;
				total_caps++;
				adjcaps = (! (0) ) ;
			}
			else
				adjcaps = (0) ;
			
			if ( (( *pc ) >= 'A' && ( *pc ) <= 'Z' ? ( *pc )+'a'-'A' : ( *pc ))  != 'i' && (( *pc ) >= 'A' && ( *pc ) <= 'Z' ? ( *pc )+'a'-'A' : ( *pc ))  != 'l' )
				fIll = (0) ;
		}
		
		if ( fIll )
			return (0) ;
	}
	
     


	{
		extern MOB_INDEX_DATA *mob_index_hash[1024 ];
		MOB_INDEX_DATA *pMobIndex;
		int iHash;
		
		for ( iHash = 0; iHash < 1024 ; iHash++ )
		{
			for ( pMobIndex  = mob_index_hash[iHash];
				pMobIndex != ((void *)0) ;
				pMobIndex  = pMobIndex->next )
			{
				if ( is_name( name, pMobIndex->player_name ) )
					return (0) ;
			}
		}
	}
	
	return (! (0) ) ;
}



 


bool check_reconnect( DESCRIPTOR_DATA *d, char *name, bool fConn )
{
	CHAR_DATA *ch;
	
	for ( ch = char_list; ch != ((void *)0) ; ch = ch->next )
	{
		if ( ! ((( ( ch )->act ) & (  1   )) )   
			&& ( !fConn || ch->desc == ((void *)0)  )
			&&   !str_cmp( d->character->name->str, ch->name->str ) )
		{
			if ( fConn == (0)  )
			{
				d->character->pcdata->pwd = g_string_assign(d->character->pcdata->pwd, ch->pcdata->pwd->str );
			}
			else
			{
				free_char( d->character );
				d->character = ch;
				ch->desc	 = d;
				ch->timer	 = 0;
				send_to_char( "Reconnecting.\n\r", ch );
				if (((( ( ch )->act ) & (  1   )) )  || ch->pcdata->obj_vnum == 0)
					act( "$n has reconnected.", ch, ((void *)0) , ((void *)0) , 0  );
				sprintf( log_buf, "%s@%s reconnected.", ch->name->str, ch->lasthost->str );
				log_string2( log_buf );
				logchan(log_buf, ((void *)0) , ((void *)0) ,(1048576 ) ,0, (12  - 4) );
				d->connected = 9 ;
				 
				 
			}
			return (! (0) ) ;
			mudsetting->last_proc_logged = 31;
	
		}
	}
	mudsetting->last_proc_logged = 32;
	
	return (0) ;
}

 


bool check_kickoff( DESCRIPTOR_DATA *d, char *name, bool fConn )
{
	CHAR_DATA *ch;
	
	for ( ch = char_list; ch != ((void *)0) ; ch = ch->next )
	{
		if ( ! ((( ( ch )->act ) & (  1   )) ) 
			&& ( !fConn || ch->desc == ((void *)0)  )
			&&   !str_cmp( d->character->name->str, ch->name->str ) )
		{
			if ( fConn == (0)  )
			{
				d->character->pcdata->pwd = g_string_assign(d->character->pcdata->pwd, ch->pcdata->pwd->str );
			}
			else
			{
				free_char( d->character );
				d->character = ch;
				ch->desc	 = d;
				ch->timer	 = 0;
				send_to_char( "You take over your body, which was already in use.\n\r", ch );
				act( "...$n's body has been taken over by another spirit!", ch, ((void *)0) , ((void *)0) , 0  );
				sprintf( log_buf, "%s@%s kicking off old link.", ch->name->str, ch->lasthost->str );
				log_string2( log_buf );
				logchan(log_buf, ((void *)0) , ((void *)0) ,(1048576 ) ,0, (12  - 4) );
				d->connected = 9 ;
				if (ch->pcdata->in_progress)
					send_to_char("You have a note in progress. Type NWRITE to continue it.\n\r",ch);
			}
			return (! (0) ) ;
			mudsetting->last_proc_logged = 33;
	
		}
	}
	mudsetting->last_proc_logged = 34;
	
	return (0) ;
}


bool check_player_ID( DESCRIPTOR_DATA *d, char *name, bool fConn )
{
	CHAR_DATA *ch;
	
	for ( ch = char_list; ch != ((void *)0) ; ch = ch->next )
	{
		if ( ! ((( ( ch )->act ) & (  1   )) ) 
			&& ( ch->id ==  d->character->id )
			&& ( !fConn || ch->desc == ((void *)0)  )
			&&   !str_cmp( d->character->name->str, ch->name->str ) )
		{
			free_char( d->character );
			d->character = ch;
			ch->desc	 = d;
			ch->timer	 = 0;
			send_to_char( "You take over your body, which was already in use.\n\r", ch );
			act( "...$n's body has been taken over by another spirit!", ch, ((void *)0) , ((void *)0) , 0  );
			sprintf( log_buf, "%s@%s kicking off old ID.", ch->name->str, ch->lasthost->str );
			log_string2( log_buf );
			logchan(log_buf, ((void *)0) , ((void *)0) ,(1048576 ) ,0, (12  - 4) );
			d->connected = 9 ;
			if (ch->pcdata->in_progress)
				send_to_char("You have a note in progress. Type NWRITE to continue it.\n\r",ch);
		   mudsetting->last_proc_logged = 35;
			return (! (0) ) ;
		}
	}
	
	mudsetting->last_proc_logged = 36;
	return (0) ;
}

bool check_newbie_playing( DESCRIPTOR_DATA *d, char *name)
{
	DESCRIPTOR_DATA *dold;
	GSList	*desc_list;
	
	for ( desc_list = descriptor_list; desc_list != ((void *)0) ; desc_list = (( desc_list ) ? (((GSList *)( desc_list ))->next) : ((void *)0) )  )
	{
		dold = desc_list->data;
		if ( dold != d  && dold->character != ((void *)0)  
			&& !str_cmp( name, dold->original ? dold->original->name->str : dold->character->name->str ) )
			return (! (0) ) ;
	}
	return (0) ;
}

 



bool check_playing( DESCRIPTOR_DATA *d, char *name )
{
	DESCRIPTOR_DATA *dold;
	GSList	*desc_list;
	
	for ( desc_list = descriptor_list; desc_list != ((void *)0) ; desc_list = (( desc_list ) ? (((GSList *)( desc_list ))->next) : ((void *)0) )  )
	{
		dold = desc_list->data;
		if ( dold != d
			&&   dold->character != ((void *)0) 
			&&   dold->connected != 1 
			&&   dold->connected != 2 
			&&   !str_cmp( name, dold->original
				? dold->original->name->str : dold->character->name->str ) )
		{
			char	buf [4096 ];
			if ( d->character != ((void *)0)  )
			{
				free_char( d->character );
				d->character = ((void *)0) ;
			}
			send_to_char("This body has been taken over!\n\r",dold->character);
			d->connected = dold->connected;
			d->character = dold->character;
			d->character->desc = d;
			send_to_char( "You take over your body, which was already in use.\n\r", d->character );
			act( "$n doubles over in agony and $s eyes roll up into $s head.", d->character, ((void *)0) , ((void *)0) , 0  );
			act( "...$n's body has been taken over by another spirit!", d->character, ((void *)0) , ((void *)0) , 0  );
			dold->character= ((void *)0) ;
			
			sprintf(buf,"Kicking off old connection %s@%s",d->character->name->str,d->host->str);
			log_string2(buf);
			logchan(log_buf, ((void *)0) , ((void *)0) ,(1048576 ) ,0, (12  - 4) );
			close_socket(dold);	 
			if (d->character->pcdata->in_progress)
				send_to_char("You have a note in progress. Type NWRITE to continue it.\n\r",d->character);
			return (! (0) ) ;
		}
	}
	
	return (0) ;
}



void stop_idling( CHAR_DATA *ch )
{
	if ( ch == ((void *)0) 
		||   ch->desc == ((void *)0) 
		||   ch->desc->connected != 9 
		||   ch->was_in_room == ((void *)0)  
		||   ch->in_room != get_room_index( 2  ) )
		return;
	
	ch->timer = 0;
	char_from_room( ch );
	char_to_room( ch, ch->was_in_room );
	ch->was_in_room	= ((void *)0) ;
	act( "$n has returned from Limbo.", ch, ((void *)0) , ((void *)0) , 0  );
	return;
}



 


void send_to_char_bw( const char *txt, CHAR_DATA *ch )
{
	 
 
 

	if ( txt != ((void *)0)  && ch->desc != ((void *)0)  )
		write_to_buffer( ch->desc, txt, strlen(txt) );
	return;
}

 

















































































































 






void page_to_char(const char *txt, CHAR_DATA *ch )
{
	GString *buf;
	GString *output;
	int 	xloop;
	
	if(((( ( ch )->act ) & (  1   )) ) )
        return;
    
	buf = g_string_new(txt);
	output = g_string_new("");

    	if( txt > 0 && ch->desc )
	{
		if( ((  ch->act ) & (  (16384 )   ))  )
		{
			for( xloop = 0; xloop < buf->len; xloop++ )
			{
				if( buf->str[xloop] == '{' )
				{
					if (((( ( ch )->class ) & (  (64 )  ))  &&  ch ->level >= (12  - 9) )  && ((( ( ch )->added ) & (  ( (524288 )  ) )) ) )
						frenzy_colour( buf->str[xloop], ch, output );
					else
						colour( buf->str[xloop], ch, output );
					continue;
				}
				output = g_string_append_c(output,buf->str[xloop]);
			}			
			ch->desc->showstr_head  = g_string_new(buf->str);
			ch->desc->showstr_head = g_string_assign( ch->desc->showstr_head, buf->str );
			ch->desc->showstr_point = g_strdup(ch->desc->showstr_head->str);
			show_string( ch->desc, "" );
			g_string_free(ch->desc->showstr_head,(! (0) ) );
			g_free( ch->desc->showstr_point);
		}
		else
		{
			for( xloop = 0; xloop < buf->len; xloop++ )
			{
				if( buf->str[xloop] == '{' )
					continue;

				output = g_string_append_c(output,buf->str[xloop]);
			}
			ch->desc->showstr_head  = g_string_new(buf->str);
			ch->desc->showstr_head = g_string_assign( ch->desc->showstr_head, buf->str );
			ch->desc->showstr_point = g_strdup(ch->desc->showstr_head->str);
			show_string( ch->desc, "" );
			g_string_free(ch->desc->showstr_head,(! (0) ) );
			g_free( ch->desc->showstr_point);
		}
	}
	g_string_free(buf,(! (0) ) );
	g_string_free(output,(! (0) ) );
	return;
}


 
void show_string(struct descriptor_data *d, char *input)
{
	char buffer[4* 4096 ];
	char buf[160 ];
	register char *scan, *chk;
	int lines = 0, toggle = 1;
	int show_lines;
	
	one_argument(input,buf);
	if (buf[0] != '\0')
	{
		if (d->showstr_head)
		{
			d->showstr_head = 0;
		}
		d->showstr_point  = 0;
		return;
	}
	
	if (d->character)
		show_lines = d->character->lines;
	else
		show_lines = 0;
	
	for (scan = buffer; ; scan++, d->showstr_point++)
	{
		if (((*scan = *d->showstr_point) == '\n' || *scan == '\r')
			&& (toggle = -toggle) < 0)
			lines++;
		
		else if (!*scan || (show_lines > 0 && lines >= show_lines))
		{
			*scan = '\0';
			write_to_buffer(d,buffer,strlen(buffer));
			for (chk = d->showstr_point; (__ctype_b[(int) ( ( *chk ) )] & (unsigned short int)   _ISspace )  ; chk++);
			{
				if (!*chk)
				{
					if (d->showstr_head)
					{
						d->showstr_head = 0;
					}
					d->showstr_point  = 0;
				}
			}
			return;
		}
	}
	return;
}



 












 












 
void ch_printf(CHAR_DATA *ch, char *fmt, ...)
{
    char buf[4096 ];	 
    va_list args;

    ( args  = ((__gnuc_va_list) __builtin_next_arg (  fmt ))) ;
    vsprintf(buf, fmt, args);
    ((void)0) ;
	
    send_to_char(buf, ch);
}

void  mxpconv(GString *output, const char *txt, CHAR_DATA *ch )
{
	GString *buffer;
	int x;
	bool fFound = (0) ;
	 

	if( ch->desc && txt )
	{
		if( ! (( ch->deaf ) & (  1048576    ))  )
		{
			buffer = g_string_new(txt);
			for( x = 0; x < buffer->len; x++ )
			{
				if( buffer->str[x] == '<' )
					fFound = (! (0) ) ;
				if( buffer->str[x] == '>' && fFound == (! (0) )  )
				{
					x++;
					fFound = (0) ;
				}
				if (fFound)
					continue;

				g_string_append_c(output, buffer->str[x]);
			}			
			g_string_append_c(output,'\0');
			g_string_free(buffer,(! (0) ) );
		}
		else
			g_string_sprintf(output,"\033[1z%s",txt);
	}
	return;
}



void frenzy_colour( char type, CHAR_DATA *ch, GString *string )
{
	char	code[ 20 ];
	
	if( ((( (  ch  )->act ) & (  1   )) )  )
		return;
	
	switch( type )
	{
		default:
			sprintf( code, ""  );
			break;
		case 'x':
			sprintf( code, ""  );
			break;
		case 'b':
			sprintf( code, ""  );
			break;
		case 'c':
			sprintf( code, ""  );
			break;
		case 'g':
			sprintf( code, ""  );
			break;
		case 'm':
			sprintf( code, ""  );
			break;
		case 'r':
			sprintf( code, ""  );
			break;
		case 'w':
			sprintf( code, ""  );
			break;
		case 'y':
			sprintf( code, ""  );
			break;
		case 'B':
			sprintf( code, ""  );
			break;
		case 'C':
			sprintf( code, ""  );
			break;
		case 'G':
			sprintf( code, ""  );
			break;
		case 'M':
			sprintf( code, ""  );
			break;
		case 'R':
			sprintf( code, ""  );
			break;
		case 'W':
			sprintf( code, ""  );
			break;
		case 'Y':
			sprintf( code, ""  );
			break;
		case 'D':
			sprintf( code, ""  );
			break;
		case '\242':
			sprintf( code, ""  );
			break;
		case '{':
			sprintf( code, "%c", '{' );
			break;
	}
	
	string = g_string_append(string,code);	
	return;
}


void colour( char type, CHAR_DATA *ch, GString *output )
{
	char	code[ 20 ];
	
	if( ((( (  ch  )->act ) & (  1   )) )  )
		return;
	
	if (type == '\0'){
		return;
	}

	switch( type )
	{
		default:
			sprintf( code, ""  );
			break;
		case 'x':
			sprintf( code, ""  );
			break;
		case 'b':
			sprintf( code, ""  );
			break;
		case 'c':
			sprintf( code, ""  );
			break;
		case 'g':
			sprintf( code, ""  );
			break;
		case 'm':
			sprintf( code, ""  );
			break;
		case 'r':
			sprintf( code, ""  );
			break;
		case 'w':
			sprintf( code, ""  );
			break;
		case 'y':
			sprintf( code, ""  );
			break;
		case 'B':
			sprintf( code, ""  );
			break;
		case 'C':
			sprintf( code, ""  );
			break;
		case 'G':
			sprintf( code, ""  );
			break;
		case 'M':
			sprintf( code, ""  );
			break;
		case 'R':
			sprintf( code, ""  );
			break;
		case 'W':
			sprintf( code, ""  );
			break;
		case 'Y':
			sprintf( code, ""  );
			break;
		case 'D':
			sprintf( code, ""  );
			break;
		case '\242':
			sprintf( code, ""  );
			break;
		case '{':
			sprintf( code, "%c", '{' );
			break;
	}
	
	g_string_append(output,code);
	
	return;
}

void colourconv( GString *output, GString *txt, CHAR_DATA *ch )
{
	int	xloop;
	
	if( ch->desc && txt )
	{
		if( ((  ch->act ) & (  (16384 )   ))  )
		{
			for( xloop = 0; xloop < txt->len; xloop++ )
			{
				if( txt->str[xloop] == '{' )
				{
					xloop++;
					if (((( ( ch )->class ) & (  (64 )  ))  &&  ch ->level >= (12  - 9) )  && ((( ( ch )->added ) & (  ( (524288 )  ) )) ) )
						frenzy_colour( txt->str[xloop], ch, output );
					else	
						colour( txt->str[xloop], ch, output );
					continue;
				}
				output = g_string_append_c(output,txt->str[xloop]);
			}			
		}
		else
		{
			for( xloop=0; xloop < txt->len; xloop++ )
			{
				if( txt->str[xloop] == '{' )
				{
					xloop++;
					continue;
				}
				g_string_append_c(output, txt->str[xloop]);
			}
		}
	}
	return;
}
 


void act( const char *format, CHAR_DATA *ch, const void *arg1, const void *arg2, int type )
{
	static char * const he_she	[] = { "it",  "he",  "she" };
	static char * const him_her	[] = { "it",  "him", "her" };
	static char * const his_her	[] = { "its", "his", "her" };
		
	GString *buf;
	GString *mxpbuf;
	char fname    [160 ];
	CHAR_DATA     *to;
    CHAR_DATA *to_old;
	CHAR_DATA     *vch = (CHAR_DATA *) arg2;
    CHAR_DATA *familiar = ((void *)0) ;
    CHAR_DATA *wizard = ((void *)0) ;

	OBJ_DATA      *obj1 = (OBJ_DATA  *) arg1;
	OBJ_DATA      *obj2 = (OBJ_DATA  *) arg2;
	OBJ_DATA      *to_obj;
	const char    *str;
	gchar         *i;
	GString          *pbuff;
	GString          *buffer;
	bool          fColour = (0) ;
    bool is_fam;
	bool is_ok;
     


	
     



	
	buf = g_string_new("");
	if ( format == ((void *)0)  || format[0] == '\0' )
		return;
	
	if (ch == ((void *)0)  || ch->in_room == ((void *)0)  )
		return;
	
	to = ch->in_room->people;
	if ( type == 2  )
	{
		if ( vch == ((void *)0)  )
		{
			bug( "Act: null vch with TO_VICT.", 0 );
			return;
		}
		
		if (vch->in_room == ((void *)0) )
			return;
		
		to = vch->in_room->people;
	}
	
	for ( ; to != ((void *)0) ; to = to->next_in_room )
	{

		buf = g_string_assign(buf,"");

		is_fam = (0) ;
		to_old = to;

		if ( type == 3  && to != ch ) continue;
		if ( type == 2  && ( to != vch || to == ch ) ) continue;
		if ( type == 0  && to == ch ) continue;
		if ( type == 1  && (to == ch || to == vch) ) continue;
		if ( type == 5  && ((( to->act ) & (  (128 )  ))  || (to == ch || to == vch))) continue;
		
		if ( to->desc == ((void *)0)  && ((( ( to )->act ) & (  1   )) )  && (wizard = to->wizard) != ((void *)0)  )
		{
	    	if (! ((( ( wizard )->act ) & (  1   )) )  && ((familiar=wizard->pcdata->familiar) != ((void *)0) )
			&& familiar == to)
	    	{
				if (to->in_room == ch->in_room && 
		    		wizard->in_room != to->in_room)
				{
		    		to = wizard;
		    		is_fam = (! (0) ) ;
				}
	    	}
		}

		if ( to->desc == ((void *)0)  || ! ( to ->position > 4 )  )
		{
	    	if (is_fam) 
	    		to = to_old;
	    	continue;
		}
		
		if (ch->in_room->vnum == 30008 )
		{
			is_ok = (0) ;
			
			if (! ((( ( ch )->act ) & (  1   )) )  && ch->pcdata->chobj != ((void *)0)  && 
				ch->pcdata->chobj->in_room != ((void *)0)  &&
				! ((( ( to )->act ) & (  1   )) )  && to->pcdata->chobj != ((void *)0)  && 
				to->pcdata->chobj->in_room != ((void *)0)  &&
				ch->in_room == to->in_room)
				is_ok = (! (0) ) ; else is_ok = (0) ;
			
			if (! ((( ( ch )->act ) & (  1   )) )  && ch->pcdata->chobj != ((void *)0)  && 
				ch->pcdata->chobj->in_obj != ((void *)0)  &&
				! ((( ( to )->act ) & (  1   )) )  && to->pcdata->chobj != ((void *)0)  && 
				to->pcdata->chobj->in_obj != ((void *)0)  &&
				ch->pcdata->chobj->in_obj == to->pcdata->chobj->in_obj)
				is_ok = (! (0) ) ; else is_ok = (0) ;

			if (!is_ok)
				continue;
		}
		
		str	= format;
		while ( *str != '\0' )
		{
			if ( *str != '$' )
			{
				buf = g_string_append_c(buf,*str);
				++str;
				continue;
			}
			fColour = (! (0) ) ;
			++str;
			
			if ( arg2 == ((void *)0)  && *str >= 'A' && *str <= 'Z' )
			{
				bug( "Act: missing arg2 for code %d.", *str );
				i = g_strdup(" <@@@> ");
			}
			else
			{
				switch ( *str )
				{
					default:  bug( "Act: bad code %d.", *str );
						i = g_strdup(" <@@@> ");				break;
		 
					case 't': i = g_strdup(arg1);				break;
					case 'T': i = g_strdup(arg2);          			break;
					case 'X': 
						  mxpbuf = g_string_new("");
						  mxpconv(mxpbuf,(char *) arg2,to);
						  i = g_strdup(mxpbuf->str);
						  g_string_free(mxpbuf,(! (0) ) );
						  break;

					case 'n': i = g_strdup(PERS( ch,  to  ));				break;
					case 'N': i = g_strdup(PERS( vch, to  ));				break;
					case 'e': i = g_strdup(he_she  [((  ch  ->sex ) < ( 0 ) ? ( 0 ) : ((  ch  ->sex ) > (  2 ) ? (  2 ) : (  ch  ->sex ))) ]);	break;
					case 'E': i = g_strdup(he_she  [((  vch ->sex ) < ( 0 ) ? ( 0 ) : ((  vch ->sex ) > (  2 ) ? (  2 ) : (  vch ->sex ))) ]);	break;
					case 'm': i = g_strdup(him_her [((  ch  ->sex ) < ( 0 ) ? ( 0 ) : ((  ch  ->sex ) > (  2 ) ? (  2 ) : (  ch  ->sex ))) ]);	break;
					case 'M': i = g_strdup(him_her [((  vch ->sex ) < ( 0 ) ? ( 0 ) : ((  vch ->sex ) > (  2 ) ? (  2 ) : (  vch ->sex ))) ]);	break;
					case 's': i = g_strdup(his_her [((  ch  ->sex ) < ( 0 ) ? ( 0 ) : ((  ch  ->sex ) > (  2 ) ? (  2 ) : (  ch  ->sex ))) ]);	break;
					case 'S': i = g_strdup(his_her [((  vch ->sex ) < ( 0 ) ? ( 0 ) : ((  vch ->sex ) > (  2 ) ? (  2 ) : (  vch ->sex ))) ]);	break;
						
					case 'p':
						i = can_see_obj( to, obj1 )
							? ( (obj1->chobj != ((void *)0)  && obj1->chobj == to)
								? g_strdup("you") : g_strdup(obj1->short_descr->str))
							: g_strdup("something");
						break;
						
					case 'P':
						i = can_see_obj( to, obj2 )
							? ( (obj2->chobj != ((void *)0)  && obj2->chobj == to)
								? g_strdup("you") : g_strdup(obj2->short_descr->str))
							: g_strdup("something");
						break;
						
					case 'd':
						if ( arg2 == ((void *)0)  || ((char *) arg2)[0] == '\0' )
						{
							i = g_strdup("door");
						}
						else
						{
							one_argument( (char *) arg2, fname );
							i = g_strdup(fname);
						}
						break;
				}
			}

			++str;
			buf = g_string_append(buf,i);
			g_free(i);
		}
		buf = g_string_append(buf,"\n\r\0");
 
		pbuff = g_string_new("");
		buffer = g_string_new(buf->str);
		colourconv( pbuff, buffer, to);

		if ( to->desc != ((void *)0)  )
		{
			if (is_fam)
			{
	    		if (to->in_room != ch->in_room && 
					familiar != ((void *)0)  && familiar->in_room == ch->in_room)
					send_to_char("[ ", to);
	    		else
	    		{
					to = to_old;
					continue;
	    		}
			}
			
			write_to_buffer( to->desc, pbuff->str, 0);
				
		}
		else
		{
			if (((( ( to )->act ) & (  1   )) ) )
			{
				if ( MOBtrigger )
					mp_act_trigger( buf->str, to, ch, arg1, arg2, (1 )  );
			}
		}
		g_string_free(pbuff,(! (0) ) );	
		g_string_free(buffer,(! (0) ) );	
		if ( ((( ( to->in_room )->mprog_flags ) & (  (  (1 )  ) )) )  )
        	rprog_act_trigger(buf->str, to->in_room, ch, (OBJ_DATA *)arg1, (void *)arg2, (1 ) );
      	
      	for ( to_obj = to->in_room->contents; to_obj;	to_obj = to_obj->next_content )
       	{
			if ( ((( ( to_obj->pIndexData )->mprog_flags ) & (  (  (1 )  ) )) )  )
        	 	oprog_act_trigger(buf->str, to_obj, ch, (OBJ_DATA *)arg1, (void *)arg2, (1 ) );
    	}
		
		if (is_fam)
			to = to_old;
		
			
	}	
	g_string_free(buf,(! (0) ) );
	return;
}

void act2( const char *format, CHAR_DATA *ch, const void *arg1, const void *arg2, int type )
{
	static char * const he_she	[] = { "it",  "he",  "she" };
	static char * const him_her	[] = { "it",  "him", "her" };
	static char * const his_her	[] = { "its", "his", "her" };
	
	OBJ_DATA      *to_obj;
	
	char buf[4096 ];
	CHAR_DATA *to;
    CHAR_DATA *to_old;
	CHAR_DATA *vch = (CHAR_DATA *) arg2;

    CHAR_DATA *familiar = ((void *)0) ;
    CHAR_DATA *wizard = ((void *)0) ;

	OBJ_DATA *obj1 = (OBJ_DATA  *) arg1;
	OBJ_DATA *obj2 = (OBJ_DATA  *) arg2;
	const char *str;
	const char *i = ((void *)0) ;
	char *point;
	GString *pbuff;
	GString *buffer;
	bool fColour = (0) ;

    bool is_fam;
	bool is_ok;
     


	if ( format == ((void *)0)  || format[0] == '\0' )
		return;
	
	to = ch->in_room->people;

	if ( type == 2  )
	{
		if ( vch == ((void *)0)  || vch->in_room == ((void *)0) )
		{
			bug( "Act: null vch with TO_VICT.", 0 );
			return;
		}
		to = vch->in_room->people;
	}

	for ( ; to != ((void *)0) ; to = to->next_in_room )
	{

		is_fam = (0) ;
		to_old = to;

		 




		if ( type == 3  && to != ch ) continue;
		if ( type == 2  && ( to != vch || to == ch ) ) continue;
		if ( type == 0  && to == ch ) continue;
		if ( type == 1  && (to == ch || to == vch) ) continue;

		if ( to->desc == ((void *)0)  && ((( ( to )->act ) & (  1   )) )  && (wizard = to->wizard) != ((void *)0)  )
		{
	    	if (! ((( ( wizard )->act ) & (  1   )) )  && ((familiar=wizard->pcdata->familiar) != ((void *)0) )
			&& familiar == to)
	    	{
				if (to->in_room == ch->in_room && 
		    		wizard->in_room != to->in_room)
				{
		    		to = wizard;
		    		is_fam = (! (0) ) ;
				}
	    	}
		}



		if ( to->desc == ((void *)0)  || ! ( to ->position > 4 )  )
		{
	    	if (is_fam) 
	    		to = to_old;
	    	continue;
		}
		
		if (ch->in_room->vnum == 30008 )
		{
			is_ok = (0) ;
			
			if (! ((( ( ch )->act ) & (  1   )) )  && ch->pcdata->chobj != ((void *)0)  && 
				ch->pcdata->chobj->in_room != ((void *)0)  &&
				! ((( ( to )->act ) & (  1   )) )  && to->pcdata->chobj != ((void *)0)  && 
				to->pcdata->chobj->in_room != ((void *)0)  &&
				ch->in_room == to->in_room)
				is_ok = (! (0) ) ; else is_ok = (0) ;
			
			if (! ((( ( ch )->act ) & (  1   )) )  && ch->pcdata->chobj != ((void *)0)  && 
				ch->pcdata->chobj->in_obj != ((void *)0)  &&
				! ((( ( to )->act ) & (  1   )) )  && to->pcdata->chobj != ((void *)0)  && 
				to->pcdata->chobj->in_obj != ((void *)0)  &&
				ch->pcdata->chobj->in_obj == to->pcdata->chobj->in_obj)
				is_ok = (! (0) ) ; else is_ok = (0) ;

			if (!is_ok)
			{
 


				continue;
			}
		}
		
		point	= buf;
		str	= format;
		while ( *str != '\0' )
		{
			if ( *str != '$' )
			{
				*point++ = *str++;
				continue;
			}
			fColour = (! (0) ) ;
			++str;
			
			if ( arg2 == ((void *)0)  && *str >= 'A' && *str <= 'Z' )
			{
 


				i = " <@@@> ";
			}
			else
			{
				switch ( *str )
				{
					default:  i = " "; break;
					case 'n': if ( ch != ((void *)0)  ) i = PERS( ch,  to  );
						else i = " ";
						break;
					case 'N': if ( vch != ((void *)0)  ) i = PERS( vch,  to  );
						else i = " ";
						break;
					case 'e': if ( ch != ((void *)0)  ) i=he_she  [((  ch  ->sex ) < ( 0 ) ? ( 0 ) : ((  ch  ->sex ) > (  2 ) ? (  2 ) : (  ch  ->sex ))) ];
						else i = " ";
						break;
					case 'E': if (vch != ((void *)0)  ) i=he_she  [((  vch  ->sex ) < ( 0 ) ? ( 0 ) : ((  vch  ->sex ) > ( 2 ) ? ( 2 ) : (  vch  ->sex ))) ];
						else i = " ";
						break;
					case 'm': if ( ch != ((void *)0)  ) i=him_her [((  ch  ->sex ) < ( 0 ) ? ( 0 ) : ((  ch  ->sex ) > (  2 ) ? (  2 ) : (  ch  ->sex ))) ];
						else i = " ";
						break;
					case 'M': if (vch != ((void *)0)  ) i=him_her [((  vch  ->sex ) < ( 0 ) ? ( 0 ) : ((  vch  ->sex ) > ( 2 ) ? ( 2 ) : (  vch  ->sex ))) ];
						else i = " ";
						break;
					case 's': if ( ch != ((void *)0)  ) i=his_her [((  ch  ->sex ) < ( 0 ) ? ( 0 ) : ((  ch  ->sex ) > (  2 ) ? (  2 ) : (  ch  ->sex ))) ];
						else i = " ";
						break;
					case 'S': if (vch != ((void *)0)  ) i=his_her [((  vch  ->sex ) < ( 0 ) ? ( 0 ) : ((  vch  ->sex ) > ( 2 ) ? ( 2 ) : (  vch  ->sex ))) ];
						else i = " ";
						break;
					case 'p':
						if (obj1 != ((void *)0) )
						{
							i = can_see_obj( to, obj1 )
								? ( (obj1->chobj != ((void *)0)  && obj1->chobj == to)
									? "you" : obj1->short_descr->str)
								: "something";
						}
						else i = " ";
						break;
						
					case 'P':
						if (obj2 != ((void *)0) )
						{
							i = can_see_obj( to, obj2 )
								? ( (obj2->chobj != ((void *)0)  && obj2->chobj == to)
									? "you" : obj2->short_descr->str)
								: "something";
						}
						else i = " ";
						break;
				}
			}
			
			++str;
			while ( ( *point = *i ) != '\0' )
				++point, ++i;
		}
		
		*point++ = '\n';
		*point++ = '\r';
		*point   = '\0';

		pbuff = g_string_new("");
		buffer = g_string_new(buf);

		colourconv( pbuff, buffer, to );

		if ( to->desc != ((void *)0)  )
		{
			if (is_fam)
			{
	    		if (to->in_room != ch->in_room && 
				familiar != ((void *)0)  && familiar->in_room == ch->in_room)
				send_to_char("[ ", to);
	    	else
	    	{
				to = to_old;
				continue;
	    	}
		}
			write_to_buffer( to->desc, pbuff->str, 0);
		}
		else
		{
			if (((( ( to )->act ) & (  1   )) ) )
			{
				if ( MOBtrigger )
					mp_act_trigger( buf, to, ch, arg1, arg2, (1 )  );
			}	
		}
		g_string_free(pbuff,(! (0) ) );
		g_string_free(buffer,(! (0) ) );
		if ( ((( ( to->in_room )->mprog_flags ) & (  (  (1 )  ) )) )  )
        	rprog_act_trigger(buf, to->in_room, ch, (OBJ_DATA *)arg1, (void *)arg2, (1 ) );
      	
      	for ( to_obj = to->in_room->contents; to_obj;	to_obj = to_obj->next_content )
       	{
			if ( ((( ( to_obj->pIndexData )->mprog_flags ) & (  (  (1 )  ) )) )  )
        	 	oprog_act_trigger(buf, to_obj, ch, (OBJ_DATA *)arg1, (void *)arg2, (1 ) );
    	}
		if (is_fam)
			to = to_old;
		 
		
	}
	return;
}



void kavitem( const char *format, CHAR_DATA *ch, const void *arg1, const void *arg2, int type )
{
	static char * const he_she	[] = { "it",  "he",  "she" };
	static char * const him_her	[] = { "it",  "him", "her" };
	static char * const his_her	[] = { "its", "his", "her" };
	
	char buf[4096 ];
	char kav[160 ];
	CHAR_DATA *to;
	CHAR_DATA *vch = (CHAR_DATA *) arg2;
	OBJ_DATA *obj1 = (OBJ_DATA  *) arg1;
	const char *str;
	const char *i = ((void *)0) ;
	char *point;
	GString *pbuff;
	GString *buffer;
	bool fColour = (0) ;
	bool is_ok;
	
     


	if ( format == ((void *)0)  || format[0] == '\0' )
		return;
	
	to = ch->in_room->people;
	if ( type == 2  )
	{
		if ( vch == ((void *)0)  )
		{
			bug( "Act: null vch with TO_VICT.", 0 );
			return;
		}
		to = vch->in_room->people;
	}
	
	for ( ; to != ((void *)0) ; to = to->next_in_room )
	{
		if ( to->desc == ((void *)0)  || ! ( to ->position > 4 )  )
			continue;
		
		if (ch->in_room->vnum == 30008 )
		{
			is_ok = (0) ;
			
			if (! ((( ( ch )->act ) & (  1   )) )  && ch->pcdata->chobj != ((void *)0)  && 
				ch->pcdata->chobj->in_room != ((void *)0)  &&
				! ((( ( to )->act ) & (  1   )) )  && to->pcdata->chobj != ((void *)0)  && 
				to->pcdata->chobj->in_room != ((void *)0)  &&
				ch->in_room == to->in_room)
				is_ok = (! (0) ) ; else is_ok = (0) ;
			
			if (! ((( ( ch )->act ) & (  1   )) )  && ch->pcdata->chobj != ((void *)0)  && 
				ch->pcdata->chobj->in_obj != ((void *)0)  &&
				! ((( ( to )->act ) & (  1   )) )  && to->pcdata->chobj != ((void *)0)  && 
				to->pcdata->chobj->in_obj != ((void *)0)  &&
				ch->pcdata->chobj->in_obj == to->pcdata->chobj->in_obj)
				is_ok = (! (0) ) ; else is_ok = (0) ;
			
			if (!is_ok) continue;
		}
		if ( type == 3  && to != ch )
			continue;
		if ( type == 2  && ( to != vch || to == ch ) )
			continue;
		if ( type == 0  && to == ch )
			continue;
		if ( type == 1  && (to == ch || to == vch) )
			continue;
		
		point	= buf;
		str	= format;
		while ( *str != '\0' )
		{
			if ( *str != '$' )
			{
				*point++ = *str++;
				continue;
			}
			fColour = (! (0) ) ;
			++str;
			
			if ( arg2 == ((void *)0)  && *str >= 'A' && *str <= 'Z' )
				i = "";
			else
			{
				switch ( *str )
				{
					default:  i = "";					break;
					case 'n': i = PERS( ch,  to  );				break;
					case 'e': i = he_she  [((  ch  ->sex ) < ( 0 ) ? ( 0 ) : ((  ch  ->sex ) > (  2 ) ? (  2 ) : (  ch  ->sex ))) ];	break;
					case 'm': i = him_her [((  ch  ->sex ) < ( 0 ) ? ( 0 ) : ((  ch  ->sex ) > (  2 ) ? (  2 ) : (  ch  ->sex ))) ];	break;
					case 's': i = his_her [((  ch  ->sex ) < ( 0 ) ? ( 0 ) : ((  ch  ->sex ) > (  2 ) ? (  2 ) : (  ch  ->sex ))) ];	break;
					case 'p':
						i = can_see_obj( to, obj1 )
							? ( (obj1->chobj != ((void *)0)  && obj1->chobj == to)
								? "you" : obj1->short_descr->str)
							: "something";
						break;
						
					case 'o':
						if (obj1 != ((void *)0) ) sprintf(kav,"%s's",obj1->short_descr->str);
						i = can_see_obj( to, obj1 )
							? ( (obj1->chobj != ((void *)0)  && obj1->chobj == to)
								? "your" : kav)
							: "something's";
						break;
						
				}
			}
			
			++str;
			while ( ( *point = *i ) != '\0' )
				++point, ++i;
		}
		
		*point++ = '\n';
		*point++ = '\r';
		*point   = '\0';
		pbuff = g_string_new("");
		buffer = g_string_new(buf);
		colourconv( pbuff, buffer, to );
		write_to_buffer( to->desc, pbuff->str, 0 );
		g_string_free(pbuff,(! (0) ) );
		g_string_free(buffer,(! (0) ) );
	}
	
	return;
}

void bust_a_prompt( DESCRIPTOR_DATA *d )
{
	CHAR_DATA *ch;
	CHAR_DATA *victim;
	CHAR_DATA *tank;
	GString   *str;
	GString   *i;
	char      *strtime;
	int xloop;
	GString   *buf;
	GString   *buf2;
	bool      is_fighting = (! (0) ) ;
	
	if ( ( ch = d->character ) == ((void *)0)  ) return;
	if ( ch->pcdata == ((void *)0)  )
	{
		send_to_char( "\n\r\n\r", ch );
		return;
	}
	if ( ch->position == 8  && ch->cprompt->str[0] == '\0' )
	{
		if ( ch->prompt->str[0] == '\0' )
		{
			send_to_char( "\n\r\n\r", ch );
			return;
		}
		is_fighting = (0) ;
	}
	else if ( ch->position != 8  && ch->prompt->str[0] == '\0' )
	{
		send_to_char( "\n\r\n\r", ch );
		return;
	}
	
	if ( ch->position == 8  && is_fighting )
		if (d->original)
			str = g_string_new(d->original->cprompt->str); 
		else
			str = g_string_new(d->character->cprompt->str);
	else
		if (d->original)
			str = g_string_new(d->original->prompt->str);
		else
			str = g_string_new(d->character->prompt->str);

	buf = g_string_new("");
	buf2 = g_string_new("");
	i = g_string_new("");

	for( xloop = 0; xloop < str->len; xloop++ )
	{
		if( str->str[xloop] != '%' )
		{
			buf = g_string_append_c(buf,str->str[xloop]);	
			continue;
		}
		xloop++;
		switch( str->str[xloop] )
		{
			default :
				i = g_string_assign(i," "); break;
			case 'h' :
				g_string_sprintf( buf2, "%d", ch->hit );
				{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (    ch   )->act ) & (  1   )) )  && ((    ch  ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   (  ch->hit  < 1) ? ""  : (  ch->hit  <   ch->max_hit ) ? scale[(4  *   ch->hit ) / ((  ch->max_hit  > 0) ?   ch->max_hit  : 1)] : ""  ); g_string_append(swh_temp,    buf2  ->str); g_string_append(swh_temp, "" ); g_string_assign(   buf2  , swh_temp->str);}}  ;
				i = g_string_assign(i,buf2->str); break;
			case 'H' :
				g_string_sprintf( buf2, "{C%d{x", ch->max_hit );
				i = g_string_assign(i,buf2->str); break;
			case 'm' :
				g_string_sprintf( buf2, "%d", ch->mana             );
				{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (    ch   )->act ) & (  1   )) )  && ((    ch  ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   (  ch->mana  < 1) ? ""  : (  ch->mana  <   ch->max_mana ) ? scale[(4  *   ch->mana ) / ((  ch->max_mana  > 0) ?   ch->max_mana  : 1)] : ""  ); g_string_append(swh_temp,    buf2  ->str); g_string_append(swh_temp, "" ); g_string_assign(   buf2  , swh_temp->str);}}  ;
				i = g_string_assign(i,buf2->str); break;
			case 'M' :
				g_string_sprintf( buf2, "{C%d{x", ch->max_mana         );
				i = g_string_assign(i,buf2->str); break;

			case 'i' :
				if ((( ch->act ) & ( (8192 )  )) ) 
				{
					g_string_sprintf( buf2, "%d", ch->invis_level) ;
				}
				else
					g_string_sprintf(buf2,"0");

				i = g_string_assign(i,buf2->str); break;

			case 'I' :
				if ((( ch->act ) & ( (131072 )  )) ) 
					g_string_sprintf(buf2,"Y");
				else
					g_string_sprintf(buf2,"N");
				i = g_string_assign(i,buf2->str); break;

			case 'v' :
				g_string_sprintf( buf2, "%d", ch->move             ); 
				{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (    ch   )->act ) & (  1   )) )  && ((    ch  ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   (  ch->move  < 1) ? ""  : (  ch->move  <   ch->max_move ) ? scale[(4  *   ch->move ) / ((  ch->max_move  > 0) ?   ch->max_move  : 1)] : ""  ); g_string_append(swh_temp,    buf2  ->str); g_string_append(swh_temp, "" ); g_string_assign(   buf2  , swh_temp->str);}}  ;
				i = g_string_assign(i,buf2->str); break;
			case 'V' :
				g_string_sprintf( buf2, "{C%d{x", ch->max_move         );
				i = g_string_assign(i,buf2->str); break;
			case 'D' :
				if (time_info.hour > 6 && time_info.hour < 18)
				{
					buf2 = g_string_assign(buf2,"None");
				}
				else
				{
					switch (weather_info[ch->in_room->sector_type].moon)
					{
						default:
							buf2 = g_string_assign(buf2,"None");
							break;
						case 4 :
							buf2 = g_string_assign(buf2,"Full");
							break;
						case 0 :
							buf2 = g_string_assign(buf2,"New");
							break;
						case 1 :
							buf2 = g_string_assign(buf2,"1st");
							break;
						case 3 :
							buf2 = g_string_assign(buf2,"Last");
							break;
					}
				}
				i = g_string_assign(i,buf2->str);
				break;
			case 't' :
				strtime                    = ctime( &current_time );
				strtime[strlen(strtime)-1] = '\0';
				g_string_sprintf( buf2, "%s", strtime         );
				{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;
				i = g_string_assign(i,buf2->str); break;
			case 'T' :
				g_string_sprintf( buf2, "%d:%s %s", time_info.hour,(time_info.half_hour == 30 ? "30" : "00"),         
						time_info.hour >= 12 ? "pm" : "am");
				{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;
				i = g_string_assign(i,buf2->str); break;
			case 'x' :
				g_string_sprintf( buf2, "%d", ch->exp              );
				{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (    ch   )->act ) & (  1   )) )  && ((    ch  ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   (  ch->exp  < 1) ? ""  : (  ch->exp  <   1000 ) ? scale[(4  *   ch->exp ) / ((  1000  > 0) ?   1000  : 1)] : ""  ); g_string_append(swh_temp,    buf2  ->str); g_string_append(swh_temp, "" ); g_string_assign(   buf2  , swh_temp->str);}}  ;
				i = g_string_assign(i,buf2->str); break;
			case 'g' :
				g_string_sprintf( buf2, "%d", ch->gold             );
				{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;
				i = g_string_assign(i,buf2->str); break;
			case 'q' :
				g_string_sprintf( buf2, "%d", ch->pcdata->quest    );
				{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;
				i = g_string_assign(i,buf2->str); break;
			case 'f' :
				if ( ( victim = ch->fighting ) == ((void *)0)  )
				{
					buf2 = g_string_assign( buf2, "N/A" );
					{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;
				}
				else
				{
					if ((victim->hit*100/victim->max_hit) < 17)
					{
						buf2 = g_string_assign(buf2, "Crippled");
						{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;}
					else if ((victim->hit*100/victim->max_hit) < 34)
					{
						buf2 = g_string_assign(buf2, "Mauled");{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;}
					else if ((victim->hit*100/victim->max_hit) < 51)
					{
						buf2 = g_string_assign(buf2, "Wounded");{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;}
					else if ((victim->hit*100/victim->max_hit) < 68)
					{
						buf2 = g_string_assign(buf2, "Injured");{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;}
					else if ((victim->hit*100/victim->max_hit) < 85)
					{
						buf2 = g_string_assign(buf2, "Hurt");{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;}
					else if ((victim->hit*100/victim->max_hit) < 100)
					{
						buf2 = g_string_assign(buf2, "Bruised");{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;}
					else if ((victim->hit*100/victim->max_hit) >= 100)
					{
						buf2 = g_string_assign(buf2, "Perfect");{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;}
				}
				i = g_string_assign(i,buf2->str); break;
			case 'F' :
				if ( ( victim = ch->fighting ) == ((void *)0)  )
				{
					buf2 = g_string_assign( buf2, "N/A" );
					{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;
				}
				else if ( ( tank = victim->fighting ) == ((void *)0)  )
				{
					buf2 = g_string_assign( buf2, "N/A" );
					{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;
				}
				else
				{
					if ((tank->hit*100/tank->max_hit) < 17)
					{buf2 = g_string_assign(buf2, "Crippled");{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;}
					else if ((tank->hit*100/tank->max_hit) < 34)
					{buf2 = g_string_assign(buf2, "Mauled");{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;}
					else if ((tank->hit*100/tank->max_hit) < 51)
					{buf2 = g_string_assign(buf2, "Wounded");{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;}
					else if ((tank->hit*100/tank->max_hit) < 68)
					{buf2 = g_string_assign(buf2, "Injured");{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;}
					else if ((tank->hit*100/tank->max_hit) < 85)
					{buf2 = g_string_assign(buf2, "Hurt");{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;}
					else if ((tank->hit*100/tank->max_hit) < 100)
					{buf2 = g_string_assign(buf2, "Bruised");{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;}
					else if ((tank->hit*100/tank->max_hit) >= 100)
					{buf2 = g_string_assign(buf2, "Perfect");{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;}
				}
				i = g_string_assign(i,buf2->str); break;
			case 'n' :
				if ( ( victim = ch->fighting ) == ((void *)0)  )
					buf2 = g_string_assign( buf2, "N/A" );
				else
				{
					if ( ((( ( victim )->affected_by ) & (  (  2097152   ) )) )  )
						buf2 = g_string_assign(buf2, victim->morph->str);
					else if ( ((( ( victim )->act ) & (  1   )) )  )
						buf2 = g_string_assign(buf2, victim->short_descr->str);
					else
						buf2 = g_string_assign(buf2, victim->name->str);
					buf2->str[0] = (( buf2->str[0] ) >= 'a' && ( buf2->str[0] ) <= 'z' ? ( buf2->str[0] )+'A'-'a' : ( buf2->str[0] )) ;
				}
				i = g_string_assign(i,buf2->str); break;
			case 'N' :
				if ( ( victim = ch->fighting ) == ((void *)0)  )
					buf2 = g_string_assign( buf2, "N/A" );
				else if ( ( tank = victim->fighting ) == ((void *)0)  )
					buf2 = g_string_assign( buf2, "N/A" );
				else
				{
					if ( ch == tank )
						buf2 = g_string_assign(buf2, "You");
					else if ( ((( ( tank )->affected_by ) & (  (  2097152   ) )) )  )
						buf2 = g_string_assign(buf2, tank->morph->str);
					else if ( ((( ( victim )->act ) & (  1   )) )  )
						buf2 = g_string_assign(buf2, tank->short_descr->str);
					else
						buf2 = g_string_assign(buf2, tank->name->str);
					buf2->str[0] = (( buf2->str[0] ) >= 'a' && ( buf2->str[0] ) <= 'z' ? ( buf2->str[0] )+'A'-'a' : ( buf2->str[0] )) ;
				}
				i = g_string_assign(i,buf2->str); break;
			case 'a' :
				g_string_sprintf( buf2, "%s", (  ch  ->alignment >= 350)  ? "good"
						: (  ch  ->alignment <= -350)  ? "evil" : "neutral" );
				{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;
				i = g_string_assign(i,buf2->str); break;
			case 'A' :
				g_string_sprintf( buf2, "%d", ch->alignment        );
				{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;
				i = g_string_assign(i,buf2->str); break;
			case 'r' :
				if( ch->in_room )
					g_string_sprintf( buf2, "%s", ch->in_room->name  );
				else
					g_string_sprintf( buf2, " "                      );
				{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;
				i = g_string_assign(i,buf2->str); break;
			case 'R' :
				if (! ((( ( ch )->act ) & (  1   )) )  && (((( ( ch )->class ) & (    (4 )   )) )  || ((( ( ch )->class ) & (    (8 )   )) ) ))
				{
					g_string_sprintf( buf2, "%d", ch->pcdata->stats[3 ]);
					{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;
				}
				else if (! ((( ( ch )->act ) & (  1   )) )  && ((( ( ch )->class ) & (  (64 )  ))  &&  ch ->level >= (12  - 9) ) )
				{
					g_string_sprintf( buf2, "%d", ch->pcdata->rage_points);
					{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;
				}
				else buf2 = g_string_assign( buf2, "0" );
				i = g_string_assign(i,buf2->str); break;
			case 'b' :
				g_string_sprintf( buf2, "%d", ch->beast );
				{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;
				i = g_string_assign(i,buf2->str); break;
			case 'B' :
				if (! ((( ( ch )->act ) & (  1   )) )  && ((( ( ch )->class ) & (    (8 )   )) ) )
				{
					g_string_sprintf( buf2, "%d", ch->pcdata->condition[2 ] );
					{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;
				}
				else buf2 = g_string_assign( buf2, "0" );
				i = g_string_assign(i,buf2->str); break;
			case 'c' :
				g_string_sprintf( buf2, "%d", char_ac(ch) );
				i = g_string_assign(i,buf2->str); break;
			case 'C' :
				g_string_sprintf( buf2, "%d", ch->paradox[0]);
				i = g_string_assign(i,buf2->str); break;
			case 'p' :
				g_string_sprintf( buf2, "%d", char_hitroll(ch) );
				{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (    ch   )->act ) & (  1   )) )  && ((    ch  ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   (  char_hitroll(ch)  < 1) ? ""  : (  char_hitroll(ch)  <   200 ) ? scale[(4  *   char_hitroll(ch) ) / ((  200  > 0) ?   200  : 1)] : ""  ); g_string_append(swh_temp,    buf2  ->str); g_string_append(swh_temp, "" ); g_string_assign(   buf2  , swh_temp->str);}}  ;
				i = g_string_assign(i,buf2->str); break;
			case 'P' :
				g_string_sprintf( buf2, "%d", char_damroll(ch) );
				{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (    ch   )->act ) & (  1   )) )  && ((    ch  ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   (  char_damroll(ch)  < 1) ? ""  : (  char_damroll(ch)  <   200 ) ? scale[(4  *   char_damroll(ch) ) / ((  200  > 0) ?   200  : 1)] : ""  ); g_string_append(swh_temp,    buf2  ->str); g_string_append(swh_temp, "" ); g_string_assign(   buf2  , swh_temp->str);}}  ;
				i = g_string_assign(i,buf2->str); break;
			case 's' :
				if (ch->race <= 0 ) buf2 = g_string_assign(buf2,"Avatar");
				else if (ch->race <= 4 ) buf2 = g_string_assign(buf2,"Lesser God");
				else if (ch->race <= 9 ) buf2 = g_string_assign(buf2,"Demigod");
				else if (ch->race <= 14) buf2 = g_string_assign(buf2,"Greater God");
				else if (ch->race <= 19) buf2 = g_string_assign(buf2,"GrandImmortal");
				else if (ch->race <= 24) buf2 = g_string_assign(buf2,"ElderImmortal");
				else                     buf2 = g_string_assign(buf2,"Immort Legend");
				i = g_string_assign(i,buf2->str); break;
			case 'S' :
				g_string_sprintf( buf2, "%d", ch->race );
				i = g_string_assign(i,buf2->str); break;
			case 'o' :
				if (! ((( ( ch )->act ) & (  1   )) )  && ch->pcdata->stage[2]+25 >= ch->pcdata->stage[1]
						&& ch->pcdata->stage[1] > 0)
				{
					g_string_sprintf( buf2, "yes" );
					{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;
				}
				else buf2 = g_string_assign( buf2, "no" );
				i = g_string_assign(i,buf2->str); break;
			case 'O' :
				if ( ( victim = ch->pcdata->partner ) == ((void *)0)  )
					buf2 = g_string_assign( buf2, "no" );
				else if (! ((( ( victim )->act ) & (  1   )) )  && victim != ((void *)0)  && victim->pcdata->stage[1] > 0
						&& victim->pcdata->stage[2]+25 >= victim->pcdata->stage[1])
				{
					g_string_sprintf( buf2, "yes" );
					{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   buf2 ->str); g_string_append(swh_temp, "" ); g_string_assign(  buf2 , swh_temp->str);}} ;
				}
				else buf2 = g_string_assign( buf2, "no" );
				i = g_string_assign(i,buf2->str); break;
			case 'l' :
				if ( ( victim = ch->pcdata->partner ) == ((void *)0)  )
					buf2 = g_string_assign( buf2, "Nobody" );
				else
				{
					if ( ((( ( victim )->affected_by ) & (  (  2097152   ) )) )  )
						buf2 = g_string_assign(buf2, victim->morph->str);
					else if ( ((( ( victim )->act ) & (  1   )) )  )
						buf2 = g_string_assign(buf2, victim->short_descr->str);
					else
						buf2 = g_string_assign(buf2, victim->name->str);
					buf2->str[0] = (( buf2->str[0] ) >= 'a' && ( buf2->str[0] ) <= 'z' ? ( buf2->str[0] )+'A'-'a' : ( buf2->str[0] )) ;
				}
				i = g_string_assign(i,buf2->str); break;
			case '%' :
				g_string_sprintf( buf2, "%%");
				i = g_string_assign(i,buf2->str); break;
		}
		 


		buf = g_string_append(buf,i->str);	
	}

	i = g_string_assign(i,buf->str);
	buf = g_string_assign(buf,"");
	colourconv(buf,i,d->character);
	write_to_buffer( d, buf->str, 0 );
	g_string_free(buf,(! (0) ) );
	g_string_free(buf2,(! (0) ) );
	g_string_free(i,(! (0) ) );
	g_string_free(str,(! (0) ) );

	return;
}

 


void write_to_buffer( DESCRIPTOR_DATA *d, const char *txt, int length )
{
	GString *buf;
	
	buf = g_string_new(txt);
	
	if (length > 0 && length <= buf->len)
	{
		buf = g_string_erase(buf,length,buf->len - length);
	}
	if ( d->outbuf->len == 0 )
	{
		if ( !d->fcommand )
		{
			d->outbuf = g_string_assign(d->outbuf,"\n\r");
		}
	}
	if (g_string_append(d->outbuf,buf->str) == ((void *)0) )
	{
		g_string_free(buf,(! (0) ) );
		return;
	}
	g_string_free(buf,(! (0) ) );
	return;
}

 





bool write_to_descriptor( int desc, char *txt, int length )
{
	int iStart;
	int nWrite;
	int nBlock;
	




	
	if ( length <= 0 )
		length = strlen(txt);
	
	for ( iStart = 0; iStart < length; iStart += nWrite )
	{
		nBlock = ((  length - iStart ) < (  4096  ) ? (  length - iStart ) : (  4096  )) ;

		if ( ( nWrite = write( desc, txt + iStart, nBlock ) ) < 0 )
		{ 
			bug( "Write_to_descriptor",0 ); 
			return (0) ; 
		}








	} 
	
	return (! (0) ) ;
}


 


void send_to_char( const char *txt, CHAR_DATA *ch )
{
	GString *buf;
	GString *output;
	int 	xloop;
	CHAR_DATA *wizard;
	CHAR_DATA *familiar;

	 
	 
	 

	buf = g_string_new(txt);
	output = g_string_new("");
	if( txt )
	{
		if( ((  ch->act ) & (  (16384 )   ))  )
		{
			for(xloop = 0; xloop < buf->len; xloop++ )
			{
				 


				if( buf->str[xloop] == '{' )
				{
					xloop++;
					if (((( ( ch )->class ) & (  (64 )  ))  &&  ch ->level >= (12  - 9) )  && ((( ( ch )->added ) & (  ( (524288 )  ) )) ) )
						frenzy_colour( buf->str[xloop], ch, output );
					else
						colour( buf->str[xloop], ch, output );
					continue;
				}
				output = g_string_append_c(output,buf->str[xloop]);
			}			
			if ( ch->desc == ((void *)0)  && ((( ( ch )->act ) & (  1   )) )  && (wizard = ch->wizard) != ((void *)0)  )
			{
				if (! ((( ( wizard )->act ) & (  1   )) )  && (familiar = wizard->pcdata->familiar) != ((void *)0)  
						&& familiar == ch && ch->in_room != wizard->in_room)
				{
					xloop++;
					 
					send_to_char("<- ",wizard);
					if ( buf != ((void *)0)  && wizard->desc != ((void *)0)  ){
						write_to_buffer( wizard->desc, buf->str, 0 );
					}
					 
					g_string_free(buf,(! (0) ) );
					g_string_free(output,(! (0) ) );
					return;
				}
			}
			if ( ch->desc )
				write_to_buffer( ch->desc, output->str, 0 );

		}
		else
		{
			for(xloop = 0; xloop < buf->len; xloop++ )
			{
				if( buf->str[xloop] == '{' )
				{
					xloop++;
					continue;
				}
				output = g_string_append_c(output,buf->str[xloop]);
			}

			if ( ch->desc == ((void *)0)  && ((( ( ch )->act ) & (  1   )) )  && (wizard = ch->wizard) != ((void *)0)  )
			{
				if (! ((( ( wizard )->act ) & (  1   )) )  && (familiar = wizard->pcdata->familiar) != ((void *)0)  
						&& familiar == ch && ch->in_room != wizard->in_room)
				{
					 
					send_to_char("<- ",wizard);
					if ( buf != ((void *)0)  && wizard->desc != ((void *)0)  )
						write_to_buffer( wizard->desc, buf->str, 0 );
					 
					g_string_free(buf,(! (0) ) );
					g_string_free(output,(! (0) ) );
					return;
				}
			}
			if ( ch->desc )
				write_to_buffer( ch->desc, output->str, 0 );
		}
	}
	g_string_free(buf,(! (0) ) );
	g_string_free(output,(! (0) ) );
	return;
}

 



int parse_snoop_string(GString *SnoopString, GString *output, int Start)
{
	int x;
	int Return_Count = 0;

	for (x = Start; x < output->len; x++)
	{
		if (output->str[x] == '\n')
		{
			g_string_append(SnoopString,"\n\r");
			x += 2;
			Return_Count = x;
			break;
		}
		g_string_append_c(SnoopString,output->str[x]);
	}

	if (x == output->len)
		Return_Count = output->len;

	return Return_Count;
}

 


void write_to_snooper( DESCRIPTOR_DATA *d, GString *output)
{
	GSList *InputBuffer;
	GSList *DisplayBuffer;
	GString *SnoopString;
	GString *DisplayString;
	int x = 0;

	InputBuffer = ((void *)0) ;
	DisplayBuffer = ((void *)0) ;

	while (x < output->len)
	{
		SnoopString = g_string_new("");
		x = parse_snoop_string(SnoopString,output,x);
		InputBuffer = g_slist_append(InputBuffer,SnoopString);
	}

	for (DisplayBuffer = InputBuffer; DisplayBuffer != ((void *)0) ; DisplayBuffer = (( DisplayBuffer ) ? (((GSList *)( DisplayBuffer ))->next) : ((void *)0) ) )
	{
		DisplayString = DisplayBuffer->data;
		if (g_strncasecmp(DisplayString->str,"?>", 2))
		{
			g_string_prepend(DisplayString,"?>");
			write_to_buffer(d,DisplayString->str,0);
		}
	}
	g_slist_free(InputBuffer);
	g_slist_free(DisplayBuffer);
	return;
}

 


bool process_output( DESCRIPTOR_DATA *d, bool fPrompt )
{
	extern bool merc_down;
	GString *pbuff;
	GString *buffer;
     


    if(!merc_down)
    {
    if ( d->showstr_point )
	    write_to_buffer( d, "[Hit Return to continue]\n\r", 0 );
    else if ( fPrompt && d->connected == 9  )
	{
		CHAR_DATA *ch;
		CHAR_DATA *victim;
		
		ch = d->original ? d->original : d->character;
		if ( (( ch->act ) & (  (64 )  ))  )
			write_to_buffer( d, "\n\r", 0 );
		
		if ((( ch->act ) & (  (1024 )  ))  && ((( ( ch )->extra ) & (  (  65536  ) )) ) )
			bust_a_prompt( d );
		else if ( (( ch->act ) & (  (1024 )  ))  )
		{
			GString *buf;
			GString *cond;
			GString *hit_str;
			GString *mana_str;
			GString *move_str;
			GString *exp_str;

			buf = g_string_new("");
			cond = g_string_new("");
			hit_str = g_string_new("");
			mana_str = g_string_new("");
			move_str = g_string_new("");
			exp_str = g_string_new("");

			
			ch = d->character;
			if (((( ( ch )->loc_hp[0] ) & (  ( 256  ) )) )  || ((( ( ch )->extra ) & (  ( 16  ) )) ) )
			{
				g_string_sprintf(exp_str, "%d ", ch->exp);
				{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (    ch   )->act ) & (  1   )) )  && ((    ch  ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   (  ch->exp  < 1) ? ""  : (  ch->exp  <   1000 ) ? scale[(4  *   ch->exp ) / ((  1000  > 0) ?   1000  : 1)] : ""  ); g_string_append(swh_temp,    exp_str  ->str); g_string_append(swh_temp, "" ); g_string_assign(   exp_str  , swh_temp->str);}}  ;
 


				g_string_sprintf( buf, "<[%sX] [?H ?M ?V]> {x",exp_str->str );
			}
			else if (ch->position == 8 )
			{
				if ( (victim = ch->fighting) != ((void *)0) );
				{		
					if ((victim->hit*100/victim->max_hit) < 17)
					{
						cond = g_string_assign(cond, "Crippled");
						{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   cond ->str); g_string_append(swh_temp, "" ); g_string_assign(  cond , swh_temp->str);}} ;
					}
					else if ((victim->hit*100/victim->max_hit) < 34)
					{
						cond = g_string_assign(cond, "Mauled");
						{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   cond ->str); g_string_append(swh_temp, "" ); g_string_assign(  cond , swh_temp->str);}} ;
					}
					else if ((victim->hit*100/victim->max_hit) < 51)
					{
						cond = g_string_assign(cond, "Wounded");
						{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   cond ->str); g_string_append(swh_temp, "" ); g_string_assign(  cond , swh_temp->str);}} ; 
					}
					else if ((victim->hit*100/victim->max_hit) < 68)
					{
						cond = g_string_assign(cond, "Injured");
						{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   cond ->str); g_string_append(swh_temp, "" ); g_string_assign(  cond , swh_temp->str);}} ;
					}
					else if ((victim->hit*100/victim->max_hit) < 85) 
					{
						cond = g_string_assign(cond, "Hurt");
						{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   cond ->str); g_string_append(swh_temp, "" ); g_string_assign(  cond , swh_temp->str);}} ;
					}
					else if ((victim->hit*100/victim->max_hit) < 100)
					{
						cond = g_string_assign(cond, "Bruised");
						{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   cond ->str); g_string_append(swh_temp, "" ); g_string_assign(  cond , swh_temp->str);}} ;
					}
					else if ((victim->hit*100/victim->max_hit) >= 100)
					{
						cond = g_string_assign(cond, "Perfect");
						{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (  ch  )->act ) & (  1   )) )  && ((  ch ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   ""  ); g_string_append(swh_temp,   cond ->str); g_string_append(swh_temp, "" ); g_string_assign(  cond , swh_temp->str);}} ;
					}
					g_string_sprintf(hit_str, "%d", ch->hit);
					{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (    ch   )->act ) & (  1   )) )  && ((    ch  ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   (  ch->hit  < 1) ? ""  : (  ch->hit  <   ch->max_hit ) ? scale[(4  *   ch->hit ) / ((  ch->max_hit  > 0) ?   ch->max_hit  : 1)] : ""  ); g_string_append(swh_temp,    hit_str  ->str); g_string_append(swh_temp, "" ); g_string_assign(   hit_str  , swh_temp->str);}}  ;
					g_string_sprintf(mana_str, "%d", ch->mana);
					{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (    ch   )->act ) & (  1   )) )  && ((    ch  ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   (  ch->mana  < 1) ? ""  : (  ch->mana  <   ch->max_mana ) ? scale[(4  *   ch->mana ) / ((  ch->max_mana  > 0) ?   ch->max_mana  : 1)] : ""  ); g_string_append(swh_temp,    mana_str  ->str); g_string_append(swh_temp, "" ); g_string_assign(   mana_str  , swh_temp->str);}}  ;
					g_string_sprintf(move_str, "%d", ch->move);
					{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (    ch   )->act ) & (  1   )) )  && ((    ch  ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   (  ch->move  < 1) ? ""  : (  ch->move  <   ch->max_move ) ? scale[(4  *   ch->move ) / ((  ch->max_move  > 0) ?   ch->max_move  : 1)] : ""  ); g_string_append(swh_temp,    move_str  ->str); g_string_append(swh_temp, "" ); g_string_assign(   move_str  , swh_temp->str);}}  ;
 


					g_string_sprintf( buf, "<[%s] [%sH %sM %sV]> {x ", cond->str, hit_str->str, mana_str->str, move_str->str );
				}
			}
			else
			{
				g_string_sprintf(hit_str, "%d", ch->hit);
				{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (    ch   )->act ) & (  1   )) )  && ((    ch  ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   (  ch->hit  < 1) ? ""  : (  ch->hit  <   ch->max_hit ) ? scale[(4  *   ch->hit ) / ((  ch->max_hit  > 0) ?   ch->max_hit  : 1)] : ""  ); g_string_append(swh_temp,    hit_str  ->str); g_string_append(swh_temp, "" ); g_string_assign(   hit_str  , swh_temp->str);}}  ;
				g_string_sprintf(mana_str, "%d", ch->mana);
				{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (    ch   )->act ) & (  1   )) )  && ((    ch  ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   (  ch->mana  < 1) ? ""  : (  ch->mana  <   ch->max_mana ) ? scale[(4  *   ch->mana ) / ((  ch->max_mana  > 0) ?   ch->max_mana  : 1)] : ""  ); g_string_append(swh_temp,    mana_str  ->str); g_string_append(swh_temp, "" ); g_string_assign(   mana_str  , swh_temp->str);}}  ;
				g_string_sprintf(move_str, "%d", ch->move);
				{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (    ch   )->act ) & (  1   )) )  && ((    ch  ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   (  ch->move  < 1) ? ""  : (  ch->move  <   ch->max_move ) ? scale[(4  *   ch->move ) / ((  ch->max_move  > 0) ?   ch->max_move  : 1)] : ""  ); g_string_append(swh_temp,    move_str  ->str); g_string_append(swh_temp, "" ); g_string_assign(   move_str  , swh_temp->str);}}  ;
				g_string_sprintf(exp_str, "%d", ch->exp);
				{GString *swh_temp; swh_temp = g_string_new("");if (! ((( (    ch   )->act ) & (  1   )) )  && ((    ch  ->act ) & (  (16384 )  )) ) { g_string_assign(swh_temp,   (  ch->exp  < 1) ? ""  : (  ch->exp  <   1000 ) ? scale[(4  *   ch->exp ) / ((  1000  > 0) ?   1000  : 1)] : ""  ); g_string_append(swh_temp,    exp_str  ->str); g_string_append(swh_temp, "" ); g_string_assign(   exp_str  , swh_temp->str);}}  ;
 



				g_string_sprintf( buf, "<[%s] [%sH %sM %sV]> {x ",exp_str->str, hit_str->str, mana_str->str, move_str->str );
			}
			pbuff = g_string_new("");
			buffer = g_string_new(buf->str);

			colourconv( pbuff, buffer, ch);

			write_to_buffer( d, pbuff->str, 0);

			g_string_free(buf,(! (0) ) );
			g_string_free(cond,(! (0) ) );
			g_string_free(hit_str,(! (0) ) );
			g_string_free(mana_str,(! (0) ) );
			g_string_free(move_str,(! (0) ) );
			g_string_free(exp_str,(! (0) ) );
			g_string_free(buffer,(! (0) ) );
			g_string_free(pbuff,(! (0) ) );

		}
	}
	
    }
     


	if ( d->outbuf->len == 0 )
		return (! (0) ) ;
	

    	 


	if ( d->snoop_by != ((void *)0)  && g_slist_length(d->snoop_by) > 0 )
	{
		GSList *desc_list = ((void *)0) ;
		DESCRIPTOR_DATA *snooper;

		for ( desc_list = d->snoop_by; desc_list != ((void *)0) ; desc_list = (( desc_list ) ? (((GSList *)( desc_list ))->next) : ((void *)0) )  )
		{
			snooper = desc_list->data;
			write_to_snooper( snooper, d->outbuf );
		}
	}
	
     


	if ( !write_to_descriptor( d->descriptor, d->outbuf->str, 0 ) )
	{
		d->outbuf = g_string_assign(d->outbuf,"");
		return (0) ;
	}
	else
	{
		d->outbuf = g_string_assign(d->outbuf,"");
		return (! (0) ) ;
	}
}

void close_socket( DESCRIPTOR_DATA *dclose )
{
	CHAR_DATA *ch;
	char log_buf[4096  ];
	
	if ( dclose->outbuf->len > 0 )
		process_output( dclose, (0)  );
	
	if (dclose->character != ((void *)0) )
		remove_snooper(dclose->character, dclose->character);

	if ( dclose->snoop_by != ((void *)0)  && g_slist_length(dclose->snoop_by) > 0)
		g_slist_free(dclose->snoop_by);

	if ( dclose->character != ((void *)0)  && dclose->connected == 9  && ((( ( dclose->character )->act ) & (  1   )) )  ) 
			do_return(dclose->character,"");
	
	if ( ( ch = dclose->character ) != ((void *)0)  )
	{
		sprintf( log_buf, "Closing link to %s.", ch->name->str );
		log_string2( log_buf );
		logchan(log_buf, ((void *)0) , ((void *)0) ,(1048576 ) ,0, (12  - 2) );
		if ( dclose->connected == 9  
			|| ((dclose->connected >= 11  )
				&& (dclose->connected <= 15 )))
		{
			if (((( ( ch )->act ) & (  1   )) )  || ch->pcdata->obj_vnum == 0)
				act( "$n has lost $s link.", ch, ((void *)0) , ((void *)0) , 0  );
			ch->desc = ((void *)0) ;
		}
	}

	remove_descriptor(dclose);
	

	close( dclose->descriptor );





	free_descriptor(dclose);	
	return;
}