ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/svn/ircd-hybrid/branches/8.2.x/src/conf_parser.c

Comparing:
ircd-hybrid/src/ircd_parser.c (file contents), Revision 1028 by michael, Sun Nov 8 13:03:38 2009 UTC vs.
ircd-hybrid/branches/8.2.x/src/conf_parser.c (file contents), Revision 9777 by michael, Thu Dec 3 15:53:16 2020 UTC

#	Line 1 | Line 1
1	+	/* A Bison parser, made by GNU Bison 3.5.1.  */
2
3	<	/* A Bison parser, made by GNU Bison 2.4.1.  */
3	>	/* Bison implementation for Yacc-like parsers in C
4	>
5	>	Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
6	>	Inc.
7
4	–	/* Skeleton implementation for Bison's Yacc-like parsers in C
5	–
6	–	Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
7	–	Free Software Foundation, Inc.
8	–
8		This program is free software: you can redistribute it and/or modify
9		it under the terms of the GNU General Public License as published by
10		the Free Software Foundation, either version 3 of the License, or
11		(at your option) any later version.
12	<
12	>
13		This program is distributed in the hope that it will be useful,
14		but WITHOUT ANY WARRANTY; without even the implied warranty of
15		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16		GNU General Public License for more details.
17	<
17	>
18		You should have received a copy of the GNU General Public License
19		along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
20
#	Line 28 | Line 27
27		special exception, which will cause the skeleton and the resulting
28		Bison output files to be licensed under the GNU General Public
29		License without this special exception.
30	<
30	>
31		This special exception was added by the Free Software Foundation in
32		version 2.2 of Bison.  */
33
#	Line 42 | Line 41
41		define necessary library symbols; they are noted "INFRINGES ON
42		USER NAME SPACE" below.  */
43
44	+	/* Undocumented macros, especially those whose name start with YY_,
45	+	are private implementation details.  Do not rely on them.  */
46	+
47		/* Identify Bison output.  */
48		#define YYBISON 1
49
50		/* Bison version.  */
51	<	#define YYBISON_VERSION "2.4.1"
51	>	#define YYBISON_VERSION "3.5.1"
52
53		/* Skeleton name.  */
54		#define YYSKELETON_NAME "yacc.c"
#	Line 60 | Line 62
62		/* Pull parsers.  */
63		#define YYPULL 1
64
63	–	/* Using locations.  */
64	–	#define YYLSP_NEEDED 0
65	–
65
66
68	–	/* Copy the first part of user declarations.  */
67
68	<	/* Line 189 of yacc.c  */
69	<	#line 25 "ircd_parser.y"
68	>	/* First part of user prologue.  */
69	>	#line 28 "conf_parser.y"
70
71
74	–	#define YY_NO_UNPUT
75	–	#include <sys/types.h>
76	–	#include <string.h>
77	–
72		#include "config.h"
73		#include "stdinc.h"
74		#include "ircd.h"
75		#include "list.h"
76	<	#include "s_conf.h"
76	>	#include "parse.h"
77	>	#include "conf.h"
78	>	#include "conf_class.h"
79	>	#include "conf_cluster.h"
80	>	#include "conf_gecos.h"
81	>	#include "conf_pseudo.h"
82	>	#include "conf_resv.h"
83	>	#include "conf_service.h"
84	>	#include "conf_shared.h"
85		#include "event.h"
86	<	#include "s_log.h"
87	<	#include "client.h"     /* for UMODE_ALL only */
86	>	#include "id.h"
87	>	#include "log.h"
88		#include "irc_string.h"
87	–	#include "irc_getaddrinfo.h"
88	–	#include "sprintf_irc.h"
89		#include "memory.h"
90		#include "modules.h"
91	<	#include "s_serv.h"
91	>	#include "server.h"
92		#include "hostmask.h"
93	–	#include "send.h"
93		#include "listener.h"
94	<	#include "resv.h"
95	<	#include "numeric.h"
97	<	#include "s_user.h"
98	<
99	<	#ifdef HAVE_LIBCRYPTO
100	<	#include <openssl/rsa.h>
101	<	#include <openssl/bio.h>
102	<	#include <openssl/pem.h>
103	<	#endif
94	>	#include "user.h"
95	>	#include "motd.h"
96
97	<	static char *class_name = NULL;
106	<	static struct ConfItem *yy_conf = NULL;
107	<	static struct AccessItem *yy_aconf = NULL;
108	<	static struct MatchItem *yy_match_item = NULL;
109	<	static struct ClassItem *yy_class = NULL;
110	<	static char *yy_class_name = NULL;
111	<
112	<	static dlink_list col_conf_list  = { NULL, NULL, 0 };
113	<	static dlink_list hub_conf_list  = { NULL, NULL, 0 };
114	<	static dlink_list leaf_conf_list = { NULL, NULL, 0 };
115	<	static unsigned int listener_flags = 0;
116	<	static unsigned int regex_ban = 0;
117	<	static char userbuf[IRCD_BUFSIZE];
118	<	static char hostbuf[IRCD_BUFSIZE];
119	<	static char reasonbuf[REASONLEN + 1];
120	<	static char gecos_name[REALLEN * 4];
121	<
122	<	static char *resv_reason = NULL;
123	<	static char *listener_address = NULL;
124	<	static int not_atom = 0;
125	<
126	<	struct CollectItem
127	<	{
128	<	dlink_node node;
129	<	char *name;
130	<	char *user;
131	<	char *host;
132	<	char *passwd;
133	<	int  port;
134	<	int  flags;
135	<	#ifdef HAVE_LIBCRYPTO
136	<	char *rsa_public_key_file;
137	<	RSA *rsa_public_key;
138	<	#endif
139	<	};
97	>	int yylex(void);
98
99	<	static void
142	<	free_collect_item(struct CollectItem *item)
99	>	static struct
100		{
101	<	MyFree(item->name);
102	<	MyFree(item->user);
103	<	MyFree(item->host);
104	<	MyFree(item->passwd);
105	<	#ifdef HAVE_LIBCRYPTO
106	<	MyFree(item->rsa_public_key_file);
107	<	#endif
108	<	MyFree(item);
109	<	}
101	>	struct
102	>	{
103	>	dlink_list list;
104	>	} mask,
105	>	leaf,
106	>	hub;
107	>
108	>	struct
109	>	{
110	>	char buf[IRCD_BUFSIZE];
111	>	} name,
112	>	nick,
113	>	user,
114	>	host,
115	>	addr,
116	>	bind,
117	>	file,
118	>	ciph,
119	>	cert,
120	>	rpass,
121	>	spass,
122	>	whois,
123	>	class,
124	>	target,
125	>	prepend,
126	>	command;
127	>
128	>	struct
129	>	{
130	>	unsigned int value;
131	>	} flags,
132	>	modes,
133	>	size,
134	>	type,
135	>	port,
136	>	timeout,
137	>	aftype,
138	>	ping_freq,
139	>	max_perip_local,
140	>	max_perip_global,
141	>	con_freq,
142	>	min_idle,
143	>	max_idle,
144	>	max_total,
145	>	max_sendq,
146	>	max_recvq,
147	>	max_channels,
148	>	cidr_bitlen_ipv4,
149	>	cidr_bitlen_ipv6,
150	>	number_per_cidr;
151	>	} block_state;
152
153		static void
154	<	unhook_hub_leaf_confs(void)
154	>	reset_block_state(void)
155		{
156	<	dlink_node *ptr;
157	<	dlink_node *next_ptr;
158	<	struct CollectItem *yy_hconf;
160	<	struct CollectItem *yy_lconf;
161	<
162	<	DLINK_FOREACH_SAFE(ptr, next_ptr, hub_conf_list.head)
163	<	{
164	<	yy_hconf = ptr->data;
165	<	dlinkDelete(&yy_hconf->node, &hub_conf_list);
166	<	free_collect_item(yy_hconf);
167	<	}
156	>	dlink_node *node, *node_next;
157	>	dlink_list *tab[] = { &block_state.mask.list,
158	>	&block_state.leaf.list, &block_state.hub.list, NULL };
159
160	<	DLINK_FOREACH_SAFE(ptr, next_ptr, leaf_conf_list.head)
160	>	for (dlink_list **list = tab; *list; ++list)
161		{
162	<	yy_lconf = ptr->data;
163	<	dlinkDelete(&yy_lconf->node, &leaf_conf_list);
164	<	free_collect_item(yy_lconf);
162	>	DLINK_FOREACH_SAFE(node, node_next, (*list)->head)
163	>	{
164	>	xfree(node->data);
165	>	dlinkDelete(node, *list);
166	>	free_dlink_node(node);
167	>	}
168		}
175	–	}
169
170	+	memset(&block_state, 0, sizeof(block_state));
171	+	}
172
173
174	<	/* Line 189 of yacc.c  */
180	<	#line 181 "ircd_parser.c"
174	>	#line 175 "conf_parser.c"
175
176	<	/* Enabling traces.  */
177	<	#ifndef YYDEBUG
178	<	# define YYDEBUG 0
179	<	#endif
176	>	# ifndef YY_CAST
177	>	#  ifdef __cplusplus
178	>	#   define YY_CAST(Type, Val) static_cast<Type> (Val)
179	>	#   define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
180	>	#  else
181	>	#   define YY_CAST(Type, Val) ((Type) (Val))
182	>	#   define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
183	>	#  endif
184	>	# endif
185	>	# ifndef YY_NULLPTR
186	>	#  if defined __cplusplus
187	>	#   if 201103L <= __cplusplus
188	>	#    define YY_NULLPTR nullptr
189	>	#   else
190	>	#    define YY_NULLPTR 0
191	>	#   endif
192	>	#  else
193	>	#   define YY_NULLPTR ((void*)0)
194	>	#  endif
195	>	# endif
196
197		/* Enabling verbose error messages.  */
198		#ifdef YYERROR_VERBOSE
#	Line 192 | Line 202 | unhook_hub_leaf_confs(void)
202		# define YYERROR_VERBOSE 0
203		#endif
204
205	<	/* Enabling the token table.  */
206	<	#ifndef YYTOKEN_TABLE
207	<	# define YYTOKEN_TABLE 0
205	>	/* Use api.header.include to #include this header
206	>	instead of duplicating it here.  */
207	>	#ifndef YY_YY_CONF_PARSER_H_INCLUDED
208	>	# define YY_YY_CONF_PARSER_H_INCLUDED
209	>	/* Debug traces.  */
210	>	#ifndef YYDEBUG
211	>	# define YYDEBUG 0
212	>	#endif
213	>	#if YYDEBUG
214	>	extern int yydebug;
215		#endif
216
217	<
201	<	/* Tokens.  */
217	>	/* Token type.  */
218		#ifndef YYTOKENTYPE
219		# define YYTOKENTYPE
220	<	/* Put the tokens into the symbol table, so that GDB and other debuggers
221	<	know about them.  */
222	<	enum yytokentype {
223	<	ACCEPT_PASSWORD = 258,
224	<	ACTION = 259,
225	<	ADMIN = 260,
226	<	AFTYPE = 261,
227	<	T_ALLOW = 262,
228	<	ANTI_NICK_FLOOD = 263,
229	<	ANTI_SPAM_EXIT_MESSAGE_TIME = 264,
230	<	AUTOCONN = 265,
231	<	T_BLOCK = 266,
232	<	BURST_AWAY = 267,
233	<	BURST_TOPICWHO = 268,
234	<	BYTES = 269,
235	<	KBYTES = 270,
236	<	MBYTES = 271,
237	<	GBYTES = 272,
238	<	TBYTES = 273,
239	<	CALLER_ID_WAIT = 274,
240	<	CAN_FLOOD = 275,
241	<	CAN_IDLE = 276,
242	<	CHANNEL = 277,
243	<	CIDR_BITLEN_IPV4 = 278,
244	<	CIDR_BITLEN_IPV6 = 279,
245	<	CIPHER_PREFERENCE = 280,
246	<	CLASS = 281,
247	<	COMPRESSED = 282,
248	<	COMPRESSION_LEVEL = 283,
249	<	CONNECT = 284,
250	<	CONNECTFREQ = 285,
251	<	CRYPTLINK = 286,
252	<	DEFAULT_CIPHER_PREFERENCE = 287,
253	<	DEFAULT_FLOODCOUNT = 288,
254	<	DEFAULT_SPLIT_SERVER_COUNT = 289,
255	<	DEFAULT_SPLIT_USER_COUNT = 290,
256	<	DENY = 291,
257	<	DESCRIPTION = 292,
258	<	DIE = 293,
259	<	DISABLE_AUTH = 294,
260	<	DISABLE_FAKE_CHANNELS = 295,
261	<	DISABLE_HIDDEN = 296,
262	<	DISABLE_LOCAL_CHANNELS = 297,
263	<	DISABLE_REMOTE_COMMANDS = 298,
264	<	DOT_IN_IP6_ADDR = 299,
265	<	DOTS_IN_IDENT = 300,
266	<	DURATION = 301,
267	<	EGDPOOL_PATH = 302,
268	<	EMAIL = 303,
269	<	ENABLE = 304,
270	<	ENCRYPTED = 305,
271	<	EXCEED_LIMIT = 306,
272	<	EXEMPT = 307,
273	<	FAILED_OPER_NOTICE = 308,
274	<	FAKENAME = 309,
275	<	IRCD_FLAGS = 310,
276	<	FLATTEN_LINKS = 311,
277	<	FFAILED_OPERLOG = 312,
278	<	FKILLLOG = 313,
279	<	FKLINELOG = 314,
280	<	FGLINELOG = 315,
281	<	FIOERRLOG = 316,
282	<	FOPERLOG = 317,
283	<	FOPERSPYLOG = 318,
284	<	FUSERLOG = 319,
285	<	GECOS = 320,
286	<	GENERAL = 321,
287	<	GLINE = 322,
288	<	GLINES = 323,
289	<	GLINE_EXEMPT = 324,
290	<	GLINE_LOG = 325,
291	<	GLINE_TIME = 326,
292	<	GLINE_MIN_CIDR = 327,
293	<	GLINE_MIN_CIDR6 = 328,
294	<	GLOBAL_KILL = 329,
295	<	IRCD_AUTH = 330,
296	<	NEED_IDENT = 331,
297	<	HAVENT_READ_CONF = 332,
298	<	HIDDEN = 333,
299	<	HIDDEN_ADMIN = 334,
300	<	HIDDEN_NAME = 335,
301	<	HIDDEN_OPER = 336,
302	<	HIDE_SERVER_IPS = 337,
303	<	HIDE_SERVERS = 338,
304	<	HIDE_SPOOF_IPS = 339,
305	<	HOST = 340,
306	<	HUB = 341,
307	<	HUB_MASK = 342,
308	<	IDLETIME = 343,
309	<	IGNORE_BOGUS_TS = 344,
310	<	INVISIBLE_ON_CONNECT = 345,
311	<	IP = 346,
312	<	KILL = 347,
313	<	KILL_CHASE_TIME_LIMIT = 348,
314	<	KLINE = 349,
315	<	KLINE_EXEMPT = 350,
316	<	KLINE_REASON = 351,
317	<	KLINE_WITH_REASON = 352,
318	<	KNOCK_DELAY = 353,
319	<	KNOCK_DELAY_CHANNEL = 354,
320	<	LEAF_MASK = 355,
321	<	LINKS_DELAY = 356,
322	<	LISTEN = 357,
323	<	T_LOG = 358,
324	<	LOGGING = 359,
325	<	LOG_LEVEL = 360,
326	<	MAX_ACCEPT = 361,
327	<	MAX_BANS = 362,
328	<	MAX_CHANS_PER_USER = 363,
329	<	MAX_GLOBAL = 364,
330	<	MAX_IDENT = 365,
331	<	MAX_LOCAL = 366,
332	<	MAX_NICK_CHANGES = 367,
333	<	MAX_NICK_TIME = 368,
334	<	MAX_NUMBER = 369,
335	<	MAX_TARGETS = 370,
336	<	MAX_WATCH = 371,
337	<	MESSAGE_LOCALE = 372,
338	<	MIN_NONWILDCARD = 373,
339	<	MIN_NONWILDCARD_SIMPLE = 374,
340	<	MODULE = 375,
341	<	MODULES = 376,
342	<	NAME = 377,
343	<	NEED_PASSWORD = 378,
344	<	NETWORK_DESC = 379,
345	<	NETWORK_NAME = 380,
346	<	NICK = 381,
347	<	NICK_CHANGES = 382,
348	<	NO_CREATE_ON_SPLIT = 383,
349	<	NO_JOIN_ON_SPLIT = 384,
350	<	NO_OPER_FLOOD = 385,
351	<	NO_TILDE = 386,
352	<	NOT = 387,
353	<	NUMBER = 388,
354	<	NUMBER_PER_IDENT = 389,
355	<	NUMBER_PER_CIDR = 390,
356	<	NUMBER_PER_IP = 391,
357	<	NUMBER_PER_IP_GLOBAL = 392,
358	<	OPERATOR = 393,
359	<	OPERS_BYPASS_CALLERID = 394,
360	<	OPER_LOG = 395,
361	<	OPER_ONLY_UMODES = 396,
362	<	OPER_PASS_RESV = 397,
363	<	OPER_SPY_T = 398,
364	<	OPER_UMODES = 399,
365	<	JOIN_FLOOD_COUNT = 400,
366	<	JOIN_FLOOD_TIME = 401,
367	<	PACE_WAIT = 402,
368	<	PACE_WAIT_SIMPLE = 403,
369	<	PASSWORD = 404,
370	<	PATH = 405,
371	<	PING_COOKIE = 406,
372	<	PING_TIME = 407,
373	<	PING_WARNING = 408,
374	<	PORT = 409,
375	<	QSTRING = 410,
376	<	QUIET_ON_BAN = 411,
377	<	REASON = 412,
378	<	REDIRPORT = 413,
379	<	REDIRSERV = 414,
380	<	REGEX_T = 415,
381	<	REHASH = 416,
382	<	TREJECT_HOLD_TIME = 417,
383	<	REMOTE = 418,
384	<	REMOTEBAN = 419,
385	<	RESTRICT_CHANNELS = 420,
386	<	RESTRICTED = 421,
387	<	RSA_PRIVATE_KEY_FILE = 422,
388	<	RSA_PUBLIC_KEY_FILE = 423,
389	<	SSL_CERTIFICATE_FILE = 424,
390	<	T_SSL_CONNECTION_METHOD = 425,
391	<	T_SSLV3 = 426,
392	<	T_TLSV1 = 427,
393	<	RESV = 428,
394	<	RESV_EXEMPT = 429,
395	<	SECONDS = 430,
396	<	MINUTES = 431,
397	<	HOURS = 432,
398	<	DAYS = 433,
399	<	WEEKS = 434,
400	<	SENDQ = 435,
401	<	SEND_PASSWORD = 436,
402	<	SERVERHIDE = 437,
403	<	SERVERINFO = 438,
404	<	SERVLINK_PATH = 439,
405	<	IRCD_SID = 440,
406	<	TKLINE_EXPIRE_NOTICES = 441,
407	<	T_SHARED = 442,
408	<	T_CLUSTER = 443,
409	<	TYPE = 444,
410	<	SHORT_MOTD = 445,
411	<	SILENT = 446,
412	<	SPOOF = 447,
413	<	SPOOF_NOTICE = 448,
414	<	STATS_E_DISABLED = 449,
415	<	STATS_I_OPER_ONLY = 450,
416	<	STATS_K_OPER_ONLY = 451,
417	<	STATS_O_OPER_ONLY = 452,
418	<	STATS_P_OPER_ONLY = 453,
419	<	TBOOL = 454,
420	<	TMASKED = 455,
421	<	T_REJECT = 456,
422	<	TS_MAX_DELTA = 457,
423	<	TS_WARN_DELTA = 458,
424	<	TWODOTS = 459,
425	<	T_ALL = 460,
426	<	T_BOTS = 461,
427	<	T_SOFTCALLERID = 462,
428	<	T_CALLERID = 463,
429	<	T_CCONN = 464,
430	<	T_CCONN_FULL = 465,
431	<	T_CLIENT_FLOOD = 466,
432	<	T_DEAF = 467,
433	<	T_DEBUG = 468,
434	<	T_DRONE = 469,
435	<	T_EXTERNAL = 470,
436	<	T_FULL = 471,
437	<	T_INVISIBLE = 472,
438	<	T_IPV4 = 473,
439	<	T_IPV6 = 474,
440	<	T_LOCOPS = 475,
441	<	T_LOGPATH = 476,
442	<	T_L_CRIT = 477,
443	<	T_L_DEBUG = 478,
444	<	T_L_ERROR = 479,
445	<	T_L_INFO = 480,
446	<	T_L_NOTICE = 481,
447	<	T_L_TRACE = 482,
448	<	T_L_WARN = 483,
449	<	T_MAX_CLIENTS = 484,
450	<	T_NCHANGE = 485,
451	<	T_OPERWALL = 486,
436	<	T_REJ = 487,
437	<	T_SERVER = 488,
438	<	T_SERVNOTICE = 489,
439	<	T_SKILL = 490,
440	<	T_SPY = 491,
441	<	T_SSL = 492,
442	<	T_UMODES = 493,
443	<	T_UNAUTH = 494,
444	<	T_UNRESV = 495,
445	<	T_UNXLINE = 496,
446	<	T_WALLOP = 497,
447	<	THROTTLE_TIME = 498,
448	<	TOPICBURST = 499,
449	<	TRUE_NO_OPER_FLOOD = 500,
450	<	TKLINE = 501,
451	<	TXLINE = 502,
452	<	TRESV = 503,
453	<	UNKLINE = 504,
454	<	USER = 505,
455	<	USE_EGD = 506,
456	<	USE_EXCEPT = 507,
457	<	USE_INVEX = 508,
458	<	USE_KNOCK = 509,
459	<	USE_LOGGING = 510,
460	<	USE_WHOIS_ACTUALLY = 511,
461	<	VHOST = 512,
462	<	VHOST6 = 513,
463	<	XLINE = 514,
464	<	WARN = 515,
465	<	WARN_NO_NLINE = 516
466	<	};
220	>	enum yytokentype
221	>	{
222	>	ACCEPT_PASSWORD = 258,
223	>	ADMIN = 259,
224	>	AFTYPE = 260,
225	>	ANTI_NICK_FLOOD = 261,
226	>	ANTI_SPAM_EXIT_MESSAGE_TIME = 262,
227	>	AUTOCONN = 263,
228	>	AWAY_COUNT = 264,
229	>	AWAY_TIME = 265,
230	>	BOT = 266,
231	>	BYTES = 267,
232	>	KBYTES = 268,
233	>	MBYTES = 269,
234	>	CALLER_ID_WAIT = 270,
235	>	CAN_FLOOD = 271,
236	>	CHANNEL = 272,
237	>	CIDR_BITLEN_IPV4 = 273,
238	>	CIDR_BITLEN_IPV6 = 274,
239	>	CLASS = 275,
240	>	CLIENT = 276,
241	>	CLOSE = 277,
242	>	CONNECT = 278,
243	>	CONNECTFREQ = 279,
244	>	CYCLE_ON_HOST_CHANGE = 280,
245	>	DEFAULT_FLOODCOUNT = 281,
246	>	DEFAULT_FLOODTIME = 282,
247	>	DEFAULT_JOIN_FLOOD_COUNT = 283,
248	>	DEFAULT_JOIN_FLOOD_TIME = 284,
249	>	DEFAULT_MAX_CLIENTS = 285,
250	>	DEFER = 286,
251	>	DENY = 287,
252	>	DESCRIPTION = 288,
253	>	DIE = 289,
254	>	DISABLE_AUTH = 290,
255	>	DISABLE_FAKE_CHANNELS = 291,
256	>	DISABLE_REMOTE_COMMANDS = 292,
257	>	DLINE_MIN_CIDR = 293,
258	>	DLINE_MIN_CIDR6 = 294,
259	>	DOTS_IN_IDENT = 295,
260	>	EMAIL = 296,
261	>	ENABLE_EXTBANS = 297,
262	>	ENCRYPTED = 298,
263	>	EXCEED_LIMIT = 299,
264	>	EXEMPT = 300,
265	>	EXPIRATION = 301,
266	>	FAILED_OPER_NOTICE = 302,
267	>	FLATTEN_LINKS = 303,
268	>	FLATTEN_LINKS_DELAY = 304,
269	>	FLATTEN_LINKS_FILE = 305,
270	>	GECOS = 306,
271	>	GENERAL = 307,
272	>	HIDDEN = 308,
273	>	HIDDEN_NAME = 309,
274	>	HIDE_CHANS = 310,
275	>	HIDE_IDLE = 311,
276	>	HIDE_IDLE_FROM_OPERS = 312,
277	>	HIDE_SERVER_IPS = 313,
278	>	HIDE_SERVERS = 314,
279	>	HIDE_SERVICES = 315,
280	>	HOST = 316,
281	>	HUB = 317,
282	>	HUB_MASK = 318,
283	>	INVISIBLE_ON_CONNECT = 319,
284	>	INVITE_CLIENT_COUNT = 320,
285	>	INVITE_CLIENT_TIME = 321,
286	>	INVITE_DELAY_CHANNEL = 322,
287	>	INVITE_EXPIRE_TIME = 323,
288	>	IP = 324,
289	>	IRCD_AUTH = 325,
290	>	IRCD_FLAGS = 326,
291	>	IRCD_SID = 327,
292	>	JOIN = 328,
293	>	KILL = 329,
294	>	KILL_CHASE_TIME_LIMIT = 330,
295	>	KLINE = 331,
296	>	KLINE_EXEMPT = 332,
297	>	KLINE_MIN_CIDR = 333,
298	>	KLINE_MIN_CIDR6 = 334,
299	>	KNOCK_CLIENT_COUNT = 335,
300	>	KNOCK_CLIENT_TIME = 336,
301	>	KNOCK_DELAY_CHANNEL = 337,
302	>	LEAF_MASK = 338,
303	>	LISTEN = 339,
304	>	MASK = 340,
305	>	MAX_ACCEPT = 341,
306	>	MAX_BANS = 342,
307	>	MAX_BANS_LARGE = 343,
308	>	MAX_CHANNELS = 344,
309	>	MAX_IDLE = 345,
310	>	MAX_INVITES = 346,
311	>	MAX_MONITOR = 347,
312	>	MAX_NICK_CHANGES = 348,
313	>	MAX_NICK_LENGTH = 349,
314	>	MAX_NICK_TIME = 350,
315	>	MAX_NUMBER = 351,
316	>	MAX_TARGETS = 352,
317	>	MAX_TOPIC_LENGTH = 353,
318	>	MIN_IDLE = 354,
319	>	MIN_NONWILDCARD = 355,
320	>	MIN_NONWILDCARD_SIMPLE = 356,
321	>	MODULE = 357,
322	>	MODULES = 358,
323	>	MOTD = 359,
324	>	NAME = 360,
325	>	NEED_IDENT = 361,
326	>	NEED_PASSWORD = 362,
327	>	NETWORK_DESCRIPTION = 363,
328	>	NETWORK_NAME = 364,
329	>	NICK = 365,
330	>	NO_OPER_FLOOD = 366,
331	>	NO_TILDE = 367,
332	>	NUMBER_PER_CIDR = 368,
333	>	NUMBER_PER_IP_GLOBAL = 369,
334	>	NUMBER_PER_IP_LOCAL = 370,
335	>	OPER_ONLY_UMODES = 371,
336	>	OPER_UMODES = 372,
337	>	OPERATOR = 373,
338	>	OPERS_BYPASS_CALLERID = 374,
339	>	PACE_WAIT = 375,
340	>	PACE_WAIT_SIMPLE = 376,
341	>	PASSWORD = 377,
342	>	PATH = 378,
343	>	PING_COOKIE = 379,
344	>	PING_TIME = 380,
345	>	PORT = 381,
346	>	RANDOM_IDLE = 382,
347	>	REASON = 383,
348	>	REDIRPORT = 384,
349	>	REDIRSERV = 385,
350	>	REHASH = 386,
351	>	REMOTE = 387,
352	>	REMOTEBAN = 388,
353	>	RESV = 389,
354	>	RESV_EXEMPT = 390,
355	>	RSA_PRIVATE_KEY_FILE = 391,
356	>	SECONDS = 392,
357	>	MINUTES = 393,
358	>	HOURS = 394,
359	>	DAYS = 395,
360	>	WEEKS = 396,
361	>	MONTHS = 397,
362	>	YEARS = 398,
363	>	SEND_PASSWORD = 399,
364	>	SENDQ = 400,
365	>	SERVERHIDE = 401,
366	>	SERVERINFO = 402,
367	>	SHORT_MOTD = 403,
368	>	SPOOF = 404,
369	>	SQUIT = 405,
370	>	STATS_E_DISABLED = 406,
371	>	STATS_I_OPER_ONLY = 407,
372	>	STATS_K_OPER_ONLY = 408,
373	>	STATS_M_OPER_ONLY = 409,
374	>	STATS_O_OPER_ONLY = 410,
375	>	STATS_P_OPER_ONLY = 411,
376	>	STATS_U_OPER_ONLY = 412,
377	>	T_ALL = 413,
378	>	T_BIND = 414,
379	>	T_CALLERID = 415,
380	>	T_CCONN = 416,
381	>	T_COMMAND = 417,
382	>	T_CLUSTER = 418,
383	>	T_DEAF = 419,
384	>	T_DEBUG = 420,
385	>	T_DLINE = 421,
386	>	T_EXTERNAL = 422,
387	>	T_FARCONNECT = 423,
388	>	T_FILE = 424,
389	>	T_FLOOD = 425,
390	>	T_GLOBOPS = 426,
391	>	T_INVISIBLE = 427,
392	>	T_IPV4 = 428,
393	>	T_IPV6 = 429,
394	>	T_LOCOPS = 430,
395	>	T_LOG = 431,
396	>	T_NCHANGE = 432,
397	>	T_NONONREG = 433,
398	>	T_OPME = 434,
399	>	T_PREPEND = 435,
400	>	T_PSEUDO = 436,
401	>	T_RECVQ = 437,
402	>	T_REJ = 438,
403	>	T_RESTART = 439,
404	>	T_SERVER = 440,
405	>	T_SERVICE = 441,
406	>	T_SERVNOTICE = 442,
407	>	T_SET = 443,
408	>	T_SHARED = 444,
409	>	T_SIZE = 445,
410	>	T_SKILL = 446,
411	>	T_SOFTCALLERID = 447,
412	>	T_SPY = 448,
413	>	T_TARGET = 449,
414	>	T_TLS = 450,
415	>	T_UMODES = 451,
416	>	T_UNDLINE = 452,
417	>	T_UNLIMITED = 453,
418	>	T_UNRESV = 454,
419	>	T_UNXLINE = 455,
420	>	T_WALLOP = 456,
421	>	T_WALLOPS = 457,
422	>	T_WEBIRC = 458,
423	>	TBOOL = 459,
424	>	THROTTLE_COUNT = 460,
425	>	THROTTLE_TIME = 461,
426	>	TIMEOUT = 462,
427	>	TLS_CERTIFICATE_FILE = 463,
428	>	TLS_CERTIFICATE_FINGERPRINT = 464,
429	>	TLS_CIPHER_LIST = 465,
430	>	TLS_CIPHER_SUITES = 466,
431	>	TLS_CONNECTION_REQUIRED = 467,
432	>	TLS_DH_PARAM_FILE = 468,
433	>	TLS_MESSAGE_DIGEST_ALGORITHM = 469,
434	>	TLS_SUPPORTED_GROUPS = 470,
435	>	TS_MAX_DELTA = 471,
436	>	TS_WARN_DELTA = 472,
437	>	TWODOTS = 473,
438	>	TYPE = 474,
439	>	UNKLINE = 475,
440	>	USE_LOGGING = 476,
441	>	USER = 477,
442	>	VHOST = 478,
443	>	VHOST6 = 479,
444	>	WARN_NO_CONNECT_BLOCK = 480,
445	>	WHOIS = 481,
446	>	WHOWAS_HISTORY_LENGTH = 482,
447	>	XLINE = 483,
448	>	XLINE_EXEMPT = 484,
449	>	QSTRING = 485,
450	>	NUMBER = 486
451	>	};
452		#endif
453		/* Tokens.  */
454		#define ACCEPT_PASSWORD 258
455	<	#define ACTION 259
456	<	#define ADMIN 260
457	<	#define AFTYPE 261
458	<	#define T_ALLOW 262
459	<	#define ANTI_NICK_FLOOD 263
460	<	#define ANTI_SPAM_EXIT_MESSAGE_TIME 264
461	<	#define AUTOCONN 265
462	<	#define T_BLOCK 266
463	<	#define BURST_AWAY 267
464	<	#define BURST_TOPICWHO 268
465	<	#define BYTES 269
466	<	#define KBYTES 270
467	<	#define MBYTES 271
468	<	#define GBYTES 272
469	<	#define TBYTES 273
470	<	#define CALLER_ID_WAIT 274
471	<	#define CAN_FLOOD 275
472	<	#define CAN_IDLE 276
473	<	#define CHANNEL 277
474	<	#define CIDR_BITLEN_IPV4 278
475	<	#define CIDR_BITLEN_IPV6 279
476	<	#define CIPHER_PREFERENCE 280
477	<	#define CLASS 281
478	<	#define COMPRESSED 282
479	<	#define COMPRESSION_LEVEL 283
480	<	#define CONNECT 284
481	<	#define CONNECTFREQ 285
482	<	#define CRYPTLINK 286
483	<	#define DEFAULT_CIPHER_PREFERENCE 287
484	<	#define DEFAULT_FLOODCOUNT 288
485	<	#define DEFAULT_SPLIT_SERVER_COUNT 289
486	<	#define DEFAULT_SPLIT_USER_COUNT 290
487	<	#define DENY 291
488	<	#define DESCRIPTION 292
489	<	#define DIE 293
490	<	#define DISABLE_AUTH 294
491	<	#define DISABLE_FAKE_CHANNELS 295
492	<	#define DISABLE_HIDDEN 296
493	<	#define DISABLE_LOCAL_CHANNELS 297
494	<	#define DISABLE_REMOTE_COMMANDS 298
495	<	#define DOT_IN_IP6_ADDR 299
496	<	#define DOTS_IN_IDENT 300
497	<	#define DURATION 301
498	<	#define EGDPOOL_PATH 302
499	<	#define EMAIL 303
500	<	#define ENABLE 304
501	<	#define ENCRYPTED 305
502	<	#define EXCEED_LIMIT 306
503	<	#define EXEMPT 307
504	<	#define FAILED_OPER_NOTICE 308
505	<	#define FAKENAME 309
506	<	#define IRCD_FLAGS 310
507	<	#define FLATTEN_LINKS 311
508	<	#define FFAILED_OPERLOG 312
509	<	#define FKILLLOG 313
510	<	#define FKLINELOG 314
511	<	#define FGLINELOG 315
512	<	#define FIOERRLOG 316
513	<	#define FOPERLOG 317
514	<	#define FOPERSPYLOG 318
515	<	#define FUSERLOG 319
516	<	#define GECOS 320
517	<	#define GENERAL 321
518	<	#define GLINE 322
519	<	#define GLINES 323
520	<	#define GLINE_EXEMPT 324
521	<	#define GLINE_LOG 325
522	<	#define GLINE_TIME 326
523	<	#define GLINE_MIN_CIDR 327
524	<	#define GLINE_MIN_CIDR6 328
525	<	#define GLOBAL_KILL 329
526	<	#define IRCD_AUTH 330
527	<	#define NEED_IDENT 331
528	<	#define HAVENT_READ_CONF 332
529	<	#define HIDDEN 333
530	<	#define HIDDEN_ADMIN 334
531	<	#define HIDDEN_NAME 335
532	<	#define HIDDEN_OPER 336
533	<	#define HIDE_SERVER_IPS 337
534	<	#define HIDE_SERVERS 338
535	<	#define HIDE_SPOOF_IPS 339
536	<	#define HOST 340
537	<	#define HUB 341
538	<	#define HUB_MASK 342
539	<	#define IDLETIME 343
540	<	#define IGNORE_BOGUS_TS 344
541	<	#define INVISIBLE_ON_CONNECT 345
542	<	#define IP 346
543	<	#define KILL 347
544	<	#define KILL_CHASE_TIME_LIMIT 348
545	<	#define KLINE 349
546	<	#define KLINE_EXEMPT 350
547	<	#define KLINE_REASON 351
548	<	#define KLINE_WITH_REASON 352
549	<	#define KNOCK_DELAY 353
550	<	#define KNOCK_DELAY_CHANNEL 354
551	<	#define LEAF_MASK 355
552	<	#define LINKS_DELAY 356
553	<	#define LISTEN 357
554	<	#define T_LOG 358
555	<	#define LOGGING 359
556	<	#define LOG_LEVEL 360
557	<	#define MAX_ACCEPT 361
558	<	#define MAX_BANS 362
559	<	#define MAX_CHANS_PER_USER 363
560	<	#define MAX_GLOBAL 364
561	<	#define MAX_IDENT 365
562	<	#define MAX_LOCAL 366
563	<	#define MAX_NICK_CHANGES 367
564	<	#define MAX_NICK_TIME 368
565	<	#define MAX_NUMBER 369
566	<	#define MAX_TARGETS 370
567	<	#define MAX_WATCH 371
568	<	#define MESSAGE_LOCALE 372
569	<	#define MIN_NONWILDCARD 373
570	<	#define MIN_NONWILDCARD_SIMPLE 374
571	<	#define MODULE 375
572	<	#define MODULES 376
573	<	#define NAME 377
574	<	#define NEED_PASSWORD 378
575	<	#define NETWORK_DESC 379
576	<	#define NETWORK_NAME 380
577	<	#define NICK 381
578	<	#define NICK_CHANGES 382
579	<	#define NO_CREATE_ON_SPLIT 383
580	<	#define NO_JOIN_ON_SPLIT 384
581	<	#define NO_OPER_FLOOD 385
582	<	#define NO_TILDE 386
583	<	#define NOT 387
584	<	#define NUMBER 388
585	<	#define NUMBER_PER_IDENT 389
586	<	#define NUMBER_PER_CIDR 390
587	<	#define NUMBER_PER_IP 391
588	<	#define NUMBER_PER_IP_GLOBAL 392
589	<	#define OPERATOR 393
590	<	#define OPERS_BYPASS_CALLERID 394
591	<	#define OPER_LOG 395
592	<	#define OPER_ONLY_UMODES 396
593	<	#define OPER_PASS_RESV 397
594	<	#define OPER_SPY_T 398
595	<	#define OPER_UMODES 399
596	<	#define JOIN_FLOOD_COUNT 400
597	<	#define JOIN_FLOOD_TIME 401
598	<	#define PACE_WAIT 402
599	<	#define PACE_WAIT_SIMPLE 403
600	<	#define PASSWORD 404
601	<	#define PATH 405
602	<	#define PING_COOKIE 406
603	<	#define PING_TIME 407
604	<	#define PING_WARNING 408
605	<	#define PORT 409
606	<	#define QSTRING 410
607	<	#define QUIET_ON_BAN 411
608	<	#define REASON 412
609	<	#define REDIRPORT 413
610	<	#define REDIRSERV 414
611	<	#define REGEX_T 415
612	<	#define REHASH 416
613	<	#define TREJECT_HOLD_TIME 417
614	<	#define REMOTE 418
615	<	#define REMOTEBAN 419
616	<	#define RESTRICT_CHANNELS 420
617	<	#define RESTRICTED 421
618	<	#define RSA_PRIVATE_KEY_FILE 422
619	<	#define RSA_PUBLIC_KEY_FILE 423
620	<	#define SSL_CERTIFICATE_FILE 424
621	<	#define T_SSL_CONNECTION_METHOD 425
622	<	#define T_SSLV3 426
623	<	#define T_TLSV1 427
624	<	#define RESV 428
625	<	#define RESV_EXEMPT 429
626	<	#define SECONDS 430
627	<	#define MINUTES 431
628	<	#define HOURS 432
629	<	#define DAYS 433
630	<	#define WEEKS 434
631	<	#define SENDQ 435
632	<	#define SEND_PASSWORD 436
633	<	#define SERVERHIDE 437
634	<	#define SERVERINFO 438
635	<	#define SERVLINK_PATH 439
636	<	#define IRCD_SID 440
637	<	#define TKLINE_EXPIRE_NOTICES 441
638	<	#define T_SHARED 442
639	<	#define T_CLUSTER 443
640	<	#define TYPE 444
641	<	#define SHORT_MOTD 445
642	<	#define SILENT 446
643	<	#define SPOOF 447
644	<	#define SPOOF_NOTICE 448
645	<	#define STATS_E_DISABLED 449
646	<	#define STATS_I_OPER_ONLY 450
647	<	#define STATS_K_OPER_ONLY 451
648	<	#define STATS_O_OPER_ONLY 452
649	<	#define STATS_P_OPER_ONLY 453
650	<	#define TBOOL 454
651	<	#define TMASKED 455
652	<	#define T_REJECT 456
653	<	#define TS_MAX_DELTA 457
654	<	#define TS_WARN_DELTA 458
655	<	#define TWODOTS 459
656	<	#define T_ALL 460
657	<	#define T_BOTS 461
658	<	#define T_SOFTCALLERID 462
659	<	#define T_CALLERID 463
660	<	#define T_CCONN 464
661	<	#define T_CCONN_FULL 465
662	<	#define T_CLIENT_FLOOD 466
663	<	#define T_DEAF 467
664	<	#define T_DEBUG 468
665	<	#define T_DRONE 469
666	<	#define T_EXTERNAL 470
667	<	#define T_FULL 471
668	<	#define T_INVISIBLE 472
669	<	#define T_IPV4 473
670	<	#define T_IPV6 474
671	<	#define T_LOCOPS 475
672	<	#define T_LOGPATH 476
673	<	#define T_L_CRIT 477
674	<	#define T_L_DEBUG 478
675	<	#define T_L_ERROR 479
676	<	#define T_L_INFO 480
677	<	#define T_L_NOTICE 481
678	<	#define T_L_TRACE 482
679	<	#define T_L_WARN 483
680	<	#define T_MAX_CLIENTS 484
681	<	#define T_NCHANGE 485
682	<	#define T_OPERWALL 486
698	<	#define T_REJ 487
699	<	#define T_SERVER 488
700	<	#define T_SERVNOTICE 489
701	<	#define T_SKILL 490
702	<	#define T_SPY 491
703	<	#define T_SSL 492
704	<	#define T_UMODES 493
705	<	#define T_UNAUTH 494
706	<	#define T_UNRESV 495
707	<	#define T_UNXLINE 496
708	<	#define T_WALLOP 497
709	<	#define THROTTLE_TIME 498
710	<	#define TOPICBURST 499
711	<	#define TRUE_NO_OPER_FLOOD 500
712	<	#define TKLINE 501
713	<	#define TXLINE 502
714	<	#define TRESV 503
715	<	#define UNKLINE 504
716	<	#define USER 505
717	<	#define USE_EGD 506
718	<	#define USE_EXCEPT 507
719	<	#define USE_INVEX 508
720	<	#define USE_KNOCK 509
721	<	#define USE_LOGGING 510
722	<	#define USE_WHOIS_ACTUALLY 511
723	<	#define VHOST 512
724	<	#define VHOST6 513
725	<	#define XLINE 514
726	<	#define WARN 515
727	<	#define WARN_NO_NLINE 516
728	<
729	<
730	<
455	>	#define ADMIN 259
456	>	#define AFTYPE 260
457	>	#define ANTI_NICK_FLOOD 261
458	>	#define ANTI_SPAM_EXIT_MESSAGE_TIME 262
459	>	#define AUTOCONN 263
460	>	#define AWAY_COUNT 264
461	>	#define AWAY_TIME 265
462	>	#define BOT 266
463	>	#define BYTES 267
464	>	#define KBYTES 268
465	>	#define MBYTES 269
466	>	#define CALLER_ID_WAIT 270
467	>	#define CAN_FLOOD 271
468	>	#define CHANNEL 272
469	>	#define CIDR_BITLEN_IPV4 273
470	>	#define CIDR_BITLEN_IPV6 274
471	>	#define CLASS 275
472	>	#define CLIENT 276
473	>	#define CLOSE 277
474	>	#define CONNECT 278
475	>	#define CONNECTFREQ 279
476	>	#define CYCLE_ON_HOST_CHANGE 280
477	>	#define DEFAULT_FLOODCOUNT 281
478	>	#define DEFAULT_FLOODTIME 282
479	>	#define DEFAULT_JOIN_FLOOD_COUNT 283
480	>	#define DEFAULT_JOIN_FLOOD_TIME 284
481	>	#define DEFAULT_MAX_CLIENTS 285
482	>	#define DEFER 286
483	>	#define DENY 287
484	>	#define DESCRIPTION 288
485	>	#define DIE 289
486	>	#define DISABLE_AUTH 290
487	>	#define DISABLE_FAKE_CHANNELS 291
488	>	#define DISABLE_REMOTE_COMMANDS 292
489	>	#define DLINE_MIN_CIDR 293
490	>	#define DLINE_MIN_CIDR6 294
491	>	#define DOTS_IN_IDENT 295
492	>	#define EMAIL 296
493	>	#define ENABLE_EXTBANS 297
494	>	#define ENCRYPTED 298
495	>	#define EXCEED_LIMIT 299
496	>	#define EXEMPT 300
497	>	#define EXPIRATION 301
498	>	#define FAILED_OPER_NOTICE 302
499	>	#define FLATTEN_LINKS 303
500	>	#define FLATTEN_LINKS_DELAY 304
501	>	#define FLATTEN_LINKS_FILE 305
502	>	#define GECOS 306
503	>	#define GENERAL 307
504	>	#define HIDDEN 308
505	>	#define HIDDEN_NAME 309
506	>	#define HIDE_CHANS 310
507	>	#define HIDE_IDLE 311
508	>	#define HIDE_IDLE_FROM_OPERS 312
509	>	#define HIDE_SERVER_IPS 313
510	>	#define HIDE_SERVERS 314
511	>	#define HIDE_SERVICES 315
512	>	#define HOST 316
513	>	#define HUB 317
514	>	#define HUB_MASK 318
515	>	#define INVISIBLE_ON_CONNECT 319
516	>	#define INVITE_CLIENT_COUNT 320
517	>	#define INVITE_CLIENT_TIME 321
518	>	#define INVITE_DELAY_CHANNEL 322
519	>	#define INVITE_EXPIRE_TIME 323
520	>	#define IP 324
521	>	#define IRCD_AUTH 325
522	>	#define IRCD_FLAGS 326
523	>	#define IRCD_SID 327
524	>	#define JOIN 328
525	>	#define KILL 329
526	>	#define KILL_CHASE_TIME_LIMIT 330
527	>	#define KLINE 331
528	>	#define KLINE_EXEMPT 332
529	>	#define KLINE_MIN_CIDR 333
530	>	#define KLINE_MIN_CIDR6 334
531	>	#define KNOCK_CLIENT_COUNT 335
532	>	#define KNOCK_CLIENT_TIME 336
533	>	#define KNOCK_DELAY_CHANNEL 337
534	>	#define LEAF_MASK 338
535	>	#define LISTEN 339
536	>	#define MASK 340
537	>	#define MAX_ACCEPT 341
538	>	#define MAX_BANS 342
539	>	#define MAX_BANS_LARGE 343
540	>	#define MAX_CHANNELS 344
541	>	#define MAX_IDLE 345
542	>	#define MAX_INVITES 346
543	>	#define MAX_MONITOR 347
544	>	#define MAX_NICK_CHANGES 348
545	>	#define MAX_NICK_LENGTH 349
546	>	#define MAX_NICK_TIME 350
547	>	#define MAX_NUMBER 351
548	>	#define MAX_TARGETS 352
549	>	#define MAX_TOPIC_LENGTH 353
550	>	#define MIN_IDLE 354
551	>	#define MIN_NONWILDCARD 355
552	>	#define MIN_NONWILDCARD_SIMPLE 356
553	>	#define MODULE 357
554	>	#define MODULES 358
555	>	#define MOTD 359
556	>	#define NAME 360
557	>	#define NEED_IDENT 361
558	>	#define NEED_PASSWORD 362
559	>	#define NETWORK_DESCRIPTION 363
560	>	#define NETWORK_NAME 364
561	>	#define NICK 365
562	>	#define NO_OPER_FLOOD 366
563	>	#define NO_TILDE 367
564	>	#define NUMBER_PER_CIDR 368
565	>	#define NUMBER_PER_IP_GLOBAL 369
566	>	#define NUMBER_PER_IP_LOCAL 370
567	>	#define OPER_ONLY_UMODES 371
568	>	#define OPER_UMODES 372
569	>	#define OPERATOR 373
570	>	#define OPERS_BYPASS_CALLERID 374
571	>	#define PACE_WAIT 375
572	>	#define PACE_WAIT_SIMPLE 376
573	>	#define PASSWORD 377
574	>	#define PATH 378
575	>	#define PING_COOKIE 379
576	>	#define PING_TIME 380
577	>	#define PORT 381
578	>	#define RANDOM_IDLE 382
579	>	#define REASON 383
580	>	#define REDIRPORT 384
581	>	#define REDIRSERV 385
582	>	#define REHASH 386
583	>	#define REMOTE 387
584	>	#define REMOTEBAN 388
585	>	#define RESV 389
586	>	#define RESV_EXEMPT 390
587	>	#define RSA_PRIVATE_KEY_FILE 391
588	>	#define SECONDS 392
589	>	#define MINUTES 393
590	>	#define HOURS 394
591	>	#define DAYS 395
592	>	#define WEEKS 396
593	>	#define MONTHS 397
594	>	#define YEARS 398
595	>	#define SEND_PASSWORD 399
596	>	#define SENDQ 400
597	>	#define SERVERHIDE 401
598	>	#define SERVERINFO 402
599	>	#define SHORT_MOTD 403
600	>	#define SPOOF 404
601	>	#define SQUIT 405
602	>	#define STATS_E_DISABLED 406
603	>	#define STATS_I_OPER_ONLY 407
604	>	#define STATS_K_OPER_ONLY 408
605	>	#define STATS_M_OPER_ONLY 409
606	>	#define STATS_O_OPER_ONLY 410
607	>	#define STATS_P_OPER_ONLY 411
608	>	#define STATS_U_OPER_ONLY 412
609	>	#define T_ALL 413
610	>	#define T_BIND 414
611	>	#define T_CALLERID 415
612	>	#define T_CCONN 416
613	>	#define T_COMMAND 417
614	>	#define T_CLUSTER 418
615	>	#define T_DEAF 419
616	>	#define T_DEBUG 420
617	>	#define T_DLINE 421
618	>	#define T_EXTERNAL 422
619	>	#define T_FARCONNECT 423
620	>	#define T_FILE 424
621	>	#define T_FLOOD 425
622	>	#define T_GLOBOPS 426
623	>	#define T_INVISIBLE 427
624	>	#define T_IPV4 428
625	>	#define T_IPV6 429
626	>	#define T_LOCOPS 430
627	>	#define T_LOG 431
628	>	#define T_NCHANGE 432
629	>	#define T_NONONREG 433
630	>	#define T_OPME 434
631	>	#define T_PREPEND 435
632	>	#define T_PSEUDO 436
633	>	#define T_RECVQ 437
634	>	#define T_REJ 438
635	>	#define T_RESTART 439
636	>	#define T_SERVER 440
637	>	#define T_SERVICE 441
638	>	#define T_SERVNOTICE 442
639	>	#define T_SET 443
640	>	#define T_SHARED 444
641	>	#define T_SIZE 445
642	>	#define T_SKILL 446
643	>	#define T_SOFTCALLERID 447
644	>	#define T_SPY 448
645	>	#define T_TARGET 449
646	>	#define T_TLS 450
647	>	#define T_UMODES 451
648	>	#define T_UNDLINE 452
649	>	#define T_UNLIMITED 453
650	>	#define T_UNRESV 454
651	>	#define T_UNXLINE 455
652	>	#define T_WALLOP 456
653	>	#define T_WALLOPS 457
654	>	#define T_WEBIRC 458
655	>	#define TBOOL 459
656	>	#define THROTTLE_COUNT 460
657	>	#define THROTTLE_TIME 461
658	>	#define TIMEOUT 462
659	>	#define TLS_CERTIFICATE_FILE 463
660	>	#define TLS_CERTIFICATE_FINGERPRINT 464
661	>	#define TLS_CIPHER_LIST 465
662	>	#define TLS_CIPHER_SUITES 466
663	>	#define TLS_CONNECTION_REQUIRED 467
664	>	#define TLS_DH_PARAM_FILE 468
665	>	#define TLS_MESSAGE_DIGEST_ALGORITHM 469
666	>	#define TLS_SUPPORTED_GROUPS 470
667	>	#define TS_MAX_DELTA 471
668	>	#define TS_WARN_DELTA 472
669	>	#define TWODOTS 473
670	>	#define TYPE 474
671	>	#define UNKLINE 475
672	>	#define USE_LOGGING 476
673	>	#define USER 477
674	>	#define VHOST 478
675	>	#define VHOST6 479
676	>	#define WARN_NO_CONNECT_BLOCK 480
677	>	#define WHOIS 481
678	>	#define WHOWAS_HISTORY_LENGTH 482
679	>	#define XLINE 483
680	>	#define XLINE_EXEMPT 484
681	>	#define QSTRING 485
682	>	#define NUMBER 486
683
684	+	/* Value type.  */
685		#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
686	<	typedef union YYSTYPE
686	>	union YYSTYPE
687		{
688	<
736	<	/* Line 214 of yacc.c  */
737	<	#line 132 "ircd_parser.y"
688	>	#line 133 "conf_parser.y"
689
690		int number;
691		char *string;
692
693	+	#line 694 "conf_parser.c"
694
695	<
696	<	/* Line 214 of yacc.c  */
745	<	#line 746 "ircd_parser.c"
746	<	} YYSTYPE;
695	>	};
696	>	typedef union YYSTYPE YYSTYPE;
697		# define YYSTYPE_IS_TRIVIAL 1
748	–	# define yystype YYSTYPE /* obsolescent; will be withdrawn */
698		# define YYSTYPE_IS_DECLARED 1
699		#endif
700
701
702	<	/* Copy the second part of user declarations.  */
702	>	extern YYSTYPE yylval;
703	>
704	>	int yyparse (void);
705	>
706	>	#endif /* !YY_YY_CONF_PARSER_H_INCLUDED  */
707
708
756	–	/* Line 264 of yacc.c  */
757	–	#line 758 "ircd_parser.c"
709
710		#ifdef short
711		# undef short
712		#endif
713
714	<	#ifdef YYTYPE_UINT8
715	<	typedef YYTYPE_UINT8 yytype_uint8;
716	<	#else
717	<	typedef unsigned char yytype_uint8;
714	>	/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
715	>	<limits.h> and (if available) <stdint.h> are included
716	>	so that the code can choose integer types of a good width.  */
717	>
718	>	#ifndef __PTRDIFF_MAX__
719	>	# include <limits.h> /* INFRINGES ON USER NAME SPACE */
720	>	# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
721	>	#  include <stdint.h> /* INFRINGES ON USER NAME SPACE */
722	>	#  define YY_STDINT_H
723	>	# endif
724		#endif
725
726	<	#ifdef YYTYPE_INT8
727	<	typedef YYTYPE_INT8 yytype_int8;
728	<	#elif (defined __STDC__ || defined __C99__FUNC__ \
729	<	|| defined __cplusplus || defined _MSC_VER)
726	>	/* Narrow types that promote to a signed type and that can represent a
727	>	signed or unsigned integer of at least N bits.  In tables they can
728	>	save space and decrease cache pressure.  Promoting to a signed type
729	>	helps avoid bugs in integer arithmetic.  */
730	>
731	>	#ifdef __INT_LEAST8_MAX__
732	>	typedef __INT_LEAST8_TYPE__ yytype_int8;
733	>	#elif defined YY_STDINT_H
734	>	typedef int_least8_t yytype_int8;
735	>	#else
736		typedef signed char yytype_int8;
737	+	#endif
738	+
739	+	#ifdef __INT_LEAST16_MAX__
740	+	typedef __INT_LEAST16_TYPE__ yytype_int16;
741	+	#elif defined YY_STDINT_H
742	+	typedef int_least16_t yytype_int16;
743		#else
744	<	typedef short int yytype_int8;
744	>	typedef short yytype_int16;
745		#endif
746
747	<	#ifdef YYTYPE_UINT16
748	<	typedef YYTYPE_UINT16 yytype_uint16;
747	>	#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
748	>	typedef __UINT_LEAST8_TYPE__ yytype_uint8;
749	>	#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
750	>	&& UINT_LEAST8_MAX <= INT_MAX)
751	>	typedef uint_least8_t yytype_uint8;
752	>	#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
753	>	typedef unsigned char yytype_uint8;
754		#else
755	<	typedef unsigned short int yytype_uint16;
755	>	typedef short yytype_uint8;
756		#endif
757
758	<	#ifdef YYTYPE_INT16
759	<	typedef YYTYPE_INT16 yytype_int16;
758	>	#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
759	>	typedef __UINT_LEAST16_TYPE__ yytype_uint16;
760	>	#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
761	>	&& UINT_LEAST16_MAX <= INT_MAX)
762	>	typedef uint_least16_t yytype_uint16;
763	>	#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
764	>	typedef unsigned short yytype_uint16;
765		#else
766	<	typedef short int yytype_int16;
766	>	typedef int yytype_uint16;
767	>	#endif
768	>
769	>	#ifndef YYPTRDIFF_T
770	>	# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
771	>	#  define YYPTRDIFF_T __PTRDIFF_TYPE__
772	>	#  define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
773	>	# elif defined PTRDIFF_MAX
774	>	#  ifndef ptrdiff_t
775	>	#   include <stddef.h> /* INFRINGES ON USER NAME SPACE */
776	>	#  endif
777	>	#  define YYPTRDIFF_T ptrdiff_t
778	>	#  define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
779	>	# else
780	>	#  define YYPTRDIFF_T long
781	>	#  define YYPTRDIFF_MAXIMUM LONG_MAX
782	>	# endif
783		#endif
784
785		#ifndef YYSIZE_T
#	Line 792 | Line 787 | typedef short int yytype_int16;
787		#  define YYSIZE_T __SIZE_TYPE__
788		# elif defined size_t
789		#  define YYSIZE_T size_t
790	<	# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
796	<	|| defined __cplusplus || defined _MSC_VER)
790	>	# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
791		#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
792		#  define YYSIZE_T size_t
793		# else
794	<	#  define YYSIZE_T unsigned int
794	>	#  define YYSIZE_T unsigned
795		# endif
796		#endif
797
798	<	#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
798	>	#define YYSIZE_MAXIMUM                                  \
799	>	YY_CAST (YYPTRDIFF_T,                                 \
800	>	(YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1)  \
801	>	? YYPTRDIFF_MAXIMUM                         \
802	>	: YY_CAST (YYSIZE_T, -1)))
803	>
804	>	#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
805	>
806	>	/* Stored state numbers (used for stacks). */
807	>	typedef yytype_int16 yy_state_t;
808	>
809	>	/* State numbers in computations.  */
810	>	typedef int yy_state_fast_t;
811
812		#ifndef YY_
813	<	# if YYENABLE_NLS
813	>	# if defined YYENABLE_NLS && YYENABLE_NLS
814		#  if ENABLE_NLS
815		#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
816	<	#   define YY_(msgid) dgettext ("bison-runtime", msgid)
816	>	#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
817		#  endif
818		# endif
819		# ifndef YY_
820	<	#  define YY_(msgid) msgid
820	>	#  define YY_(Msgid) Msgid
821	>	# endif
822	>	#endif
823	>
824	>	#ifndef YY_ATTRIBUTE_PURE
825	>	# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
826	>	#  define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
827	>	# else
828	>	#  define YY_ATTRIBUTE_PURE
829	>	# endif
830	>	#endif
831	>
832	>	#ifndef YY_ATTRIBUTE_UNUSED
833	>	# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
834	>	#  define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
835	>	# else
836	>	#  define YY_ATTRIBUTE_UNUSED
837		# endif
838		#endif
839
840		/* Suppress unused-variable warnings by "using" E.  */
841		#if ! defined lint || defined __GNUC__
842	<	# define YYUSE(e) ((void) (e))
842	>	# define YYUSE(E) ((void) (E))
843		#else
844	<	# define YYUSE(e) /* empty */
844	>	# define YYUSE(E) /* empty */
845		#endif
846
847	<	/* Identity function, used to suppress warnings about constant conditions.  */
848	<	#ifndef lint
849	<	# define YYID(n) (n)
850	<	#else
851	<	#if (defined __STDC__ || defined __C99__FUNC__ \
852	<	|| defined __cplusplus || defined _MSC_VER)
853	<	static int
854	<	YYID (int yyi)
847	>	#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
848	>	/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
849	>	# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                            \
850	>	_Pragma ("GCC diagnostic push")                                     \
851	>	_Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")              \
852	>	_Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
853	>	# define YY_IGNORE_MAYBE_UNINITIALIZED_END      \
854	>	_Pragma ("GCC diagnostic pop")
855		#else
856	<	static int
835	<	YYID (yyi)
836	<	int yyi;
856	>	# define YY_INITIAL_VALUE(Value) Value
857		#endif
858	<	{
859	<	return yyi;
860	<	}
858	>	#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
859	>	# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
860	>	# define YY_IGNORE_MAYBE_UNINITIALIZED_END
861	>	#endif
862	>	#ifndef YY_INITIAL_VALUE
863	>	# define YY_INITIAL_VALUE(Value) /* Nothing. */
864	>	#endif
865	>
866	>	#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
867	>	# define YY_IGNORE_USELESS_CAST_BEGIN                          \
868	>	_Pragma ("GCC diagnostic push")                            \
869	>	_Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
870	>	# define YY_IGNORE_USELESS_CAST_END            \
871	>	_Pragma ("GCC diagnostic pop")
872	>	#endif
873	>	#ifndef YY_IGNORE_USELESS_CAST_BEGIN
874	>	# define YY_IGNORE_USELESS_CAST_BEGIN
875	>	# define YY_IGNORE_USELESS_CAST_END
876		#endif
877
878	+
879	+	#define YY_ASSERT(E) ((void) (0 && (E)))
880	+
881		#if ! defined yyoverflow || YYERROR_VERBOSE
882
883		/* The parser invokes alloca or malloc; define the necessary symbols.  */
#	Line 857 | Line 895 | YYID (yyi)
895		#    define alloca _alloca
896		#   else
897		#    define YYSTACK_ALLOC alloca
898	<	#    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
861	<	|| defined __cplusplus || defined _MSC_VER)
898	>	#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
899		#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
900	<	#     ifndef _STDLIB_H
901	<	#      define _STDLIB_H 1
900	>	/* Use EXIT_SUCCESS as a witness for stdlib.h.  */
901	>	#     ifndef EXIT_SUCCESS
902	>	#      define EXIT_SUCCESS 0
903		#     endif
904		#    endif
905		#   endif
#	Line 869 | Line 907 | YYID (yyi)
907		# endif
908
909		# ifdef YYSTACK_ALLOC
910	<	/* Pacify GCC's `empty if-body' warning.  */
911	<	#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
910	>	/* Pacify GCC's 'empty if-body' warning.  */
911	>	#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
912		#  ifndef YYSTACK_ALLOC_MAXIMUM
913		/* The OS might guarantee only one guard page at the bottom of the stack,
914		and a page size can be as small as 4096 bytes.  So we cannot safely
#	Line 884 | Line 922 | YYID (yyi)
922		#  ifndef YYSTACK_ALLOC_MAXIMUM
923		#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
924		#  endif
925	<	#  if (defined __cplusplus && ! defined _STDLIB_H \
925	>	#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
926		&& ! ((defined YYMALLOC || defined malloc) \
927	<	&& (defined YYFREE || defined free)))
927	>	&& (defined YYFREE || defined free)))
928		#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
929	<	#   ifndef _STDLIB_H
930	<	#    define _STDLIB_H 1
929	>	#   ifndef EXIT_SUCCESS
930	>	#    define EXIT_SUCCESS 0
931		#   endif
932		#  endif
933		#  ifndef YYMALLOC
934		#   define YYMALLOC malloc
935	<	#   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
898	<	|| defined __cplusplus || defined _MSC_VER)
935	>	#   if ! defined malloc && ! defined EXIT_SUCCESS
936		void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
937		#   endif
938		#  endif
939		#  ifndef YYFREE
940		#   define YYFREE free
941	<	#   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
905	<	|| defined __cplusplus || defined _MSC_VER)
941	>	#   if ! defined free && ! defined EXIT_SUCCESS
942		void free (void *); /* INFRINGES ON USER NAME SPACE */
943		#   endif
944		#  endif
#	Line 912 | Line 948 | void free (void *); /* INFRINGES ON USER
948
949		#if (! defined yyoverflow \
950		&& (! defined __cplusplus \
951	<	|| (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
951	>	|| (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
952
953		/* A type that is properly aligned for any stack member.  */
954		union yyalloc
955		{
956	<	yytype_int16 yyss_alloc;
956	>	yy_state_t yyss_alloc;
957		YYSTYPE yyvs_alloc;
958		};
959
960		/* The size of the maximum gap between one aligned stack and the next.  */
961	<	# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
961	>	# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
962
963		/* The size of an array large to enough to hold all stacks, each with
964		N elements.  */
965		# define YYSTACK_BYTES(N) \
966	<	((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
966	>	((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
967		+ YYSTACK_GAP_MAXIMUM)
968
969	<	/* Copy COUNT objects from FROM to TO.  The source and destination do
934	<	not overlap.  */
935	<	# ifndef YYCOPY
936	<	#  if defined __GNUC__ && 1 < __GNUC__
937	<	#   define YYCOPY(To, From, Count) \
938	<	__builtin_memcpy (To, From, (Count) * sizeof (*(From)))
939	<	#  else
940	<	#   define YYCOPY(To, From, Count)              \
941	<	do                                        \
942	<	{                                       \
943	<	YYSIZE_T yyi;                         \
944	<	for (yyi = 0; yyi < (Count); yyi++)   \
945	<	(To)[yyi] = (From)[yyi];            \
946	<	}                                       \
947	<	while (YYID (0))
948	<	#  endif
949	<	# endif
969	>	# define YYCOPY_NEEDED 1
970
971		/* Relocate STACK from its old location to the new one.  The
972		local variables YYSIZE and YYSTACKSIZE give the old and new number of
973		elements in the stack, and YYPTR gives the new location of the
974		stack.  Advance YYPTR to a properly aligned location for the next
975		stack.  */
976	<	# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
977	<	do                                                                  \
978	<	{                                                                 \
979	<	YYSIZE_T yynewbytes;                                            \
980	<	YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
981	<	Stack = &yyptr->Stack_alloc;                                    \
982	<	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
983	<	yyptr += yynewbytes / sizeof (*yyptr);                          \
984	<	}                                                                 \
985	<	while (YYID (0))
976	>	# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
977	>	do                                                                  \
978	>	{                                                                 \
979	>	YYPTRDIFF_T yynewbytes;                                         \
980	>	YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
981	>	Stack = &yyptr->Stack_alloc;                                    \
982	>	yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
983	>	yyptr += yynewbytes / YYSIZEOF (*yyptr);                        \
984	>	}                                                                 \
985	>	while (0)
986
987		#endif
988
989	+	#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
990	+	/* Copy COUNT objects from SRC to DST.  The source and destination do
991	+	not overlap.  */
992	+	# ifndef YYCOPY
993	+	#  if defined __GNUC__ && 1 < __GNUC__
994	+	#   define YYCOPY(Dst, Src, Count) \
995	+	__builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
996	+	#  else
997	+	#   define YYCOPY(Dst, Src, Count)              \
998	+	do                                        \
999	+	{                                       \
1000	+	YYPTRDIFF_T yyi;                      \
1001	+	for (yyi = 0; yyi < (Count); yyi++)   \
1002	+	(Dst)[yyi] = (Src)[yyi];            \
1003	+	}                                       \
1004	+	while (0)
1005	+	#  endif
1006	+	# endif
1007	+	#endif /* !YYCOPY_NEEDED */
1008	+
1009		/* YYFINAL -- State number of the termination state.  */
1010		#define YYFINAL  2
1011		/* YYLAST -- Last index in YYTABLE.  */
1012	<	#define YYLAST   1413
1012	>	#define YYLAST   1240
1013
1014		/* YYNTOKENS -- Number of terminals.  */
1015	<	#define YYNTOKENS  267
1015	>	#define YYNTOKENS  238
1016		/* YYNNTS -- Number of nonterminals.  */
1017	<	#define YYNNTS  346
1017	>	#define YYNNTS  294
1018		/* YYNRULES -- Number of rules.  */
1019	<	#define YYNRULES  743
1020	<	/* YYNRULES -- Number of states.  */
1021	<	#define YYNSTATES  1494
1019	>	#define YYNRULES  665
1020	>	/* YYNSTATES -- Number of states.  */
1021	>	#define YYNSTATES  1311
1022
983	–	/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
1023		#define YYUNDEFTOK  2
1024	<	#define YYMAXUTOK   516
1024	>	#define YYMAXUTOK   486
1025	>
1026
1027	<	#define YYTRANSLATE(YYX)                                                \
1028	<	((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1027	>	/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
1028	>	as returned by yylex, with out-of-bounds checking.  */
1029	>	#define YYTRANSLATE(YYX)                                                \
1030	>	(0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1031
1032	<	/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
1033	<	static const yytype_uint16 yytranslate[] =
1032	>	/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
1033	>	as returned by yylex.  */
1034	>	static const yytype_uint8 yytranslate[] =
1035		{
1036		0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1037		2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1038		2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1039		2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1040	<	2,     2,     2,     2,   266,     2,     2,     2,     2,     2,
1041	<	2,     2,     2,     2,     2,     2,     2,     2,     2,   262,
1042	<	2,   265,     2,     2,     2,     2,     2,     2,     2,     2,
1040	>	2,     2,     2,     2,   236,     2,     2,     2,     2,     2,
1041	>	2,     2,     2,     2,     2,     2,     2,     2,   237,   232,
1042	>	2,   235,     2,     2,     2,     2,     2,     2,     2,     2,
1043		2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1044		2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1045		2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1046		2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1047		2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1048	<	2,     2,     2,   264,     2,   263,     2,     2,     2,     2,
1048	>	2,     2,     2,   234,     2,   233,     2,     2,     2,     2,
1049		2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1050		2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1051		2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
#	Line 1038 | Line 1081 | static const yytype_uint16 yytranslate[]
1081		195,   196,   197,   198,   199,   200,   201,   202,   203,   204,
1082		205,   206,   207,   208,   209,   210,   211,   212,   213,   214,
1083		215,   216,   217,   218,   219,   220,   221,   222,   223,   224,
1084	<	225,   226,   227,   228,   229,   230,   231,   232,   233,   234,
1042	<	235,   236,   237,   238,   239,   240,   241,   242,   243,   244,
1043	<	245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
1044	<	255,   256,   257,   258,   259,   260,   261
1084	>	225,   226,   227,   228,   229,   230,   231
1085		};
1086
1087		#if YYDEBUG
1088	<	/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1089	<	YYRHS.  */
1050	<	static const yytype_uint16 yyprhs[] =
1051	<	{
1052	<	0,     0,     3,     4,     7,     9,    11,    13,    15,    17,
1053	<	19,    21,    23,    25,    27,    29,    31,    33,    35,    37,
1054	<	39,    41,    43,    45,    47,    50,    53,    54,    56,    59,
1055	<	63,    67,    71,    75,    79,    80,    82,    85,    89,    93,
1056	<	97,   103,   106,   108,   110,   112,   115,   120,   125,   131,
1057	<	134,   136,   138,   140,   142,   144,   146,   148,   150,   152,
1058	<	154,   156,   158,   160,   163,   164,   170,   174,   176,   178,
1059	<	180,   185,   190,   195,   200,   205,   210,   215,   220,   225,
1060	<	230,   235,   241,   244,   246,   248,   250,   252,   255,   260,
1061	<	265,   270,   276,   279,   281,   283,   285,   287,   289,   291,
1062	<	293,   295,   297,   299,   301,   303,   305,   308,   313,   318,
1063	<	323,   328,   333,   338,   343,   348,   353,   358,   363,   368,
1064	<	373,   378,   383,   388,   393,   398,   399,   407,   408,   410,
1065	<	413,   415,   417,   419,   421,   423,   425,   427,   429,   431,
1066	<	433,   435,   437,   439,   441,   443,   445,   447,   449,   451,
1067	<	453,   455,   457,   459,   462,   467,   469,   474,   479,   484,
1068	<	489,   494,   495,   501,   505,   507,   509,   511,   513,   515,
1069	<	517,   519,   521,   523,   525,   527,   529,   531,   533,   535,
1070	<	537,   539,   541,   543,   545,   550,   555,   560,   565,   570,
1071	<	575,   580,   585,   590,   595,   600,   605,   610,   615,   616,
1072	<	622,   626,   628,   629,   633,   634,   637,   639,   641,   643,
1073	<	645,   647,   649,   651,   653,   655,   657,   659,   661,   663,
1074	<	665,   667,   669,   670,   678,   679,   681,   684,   686,   688,
1075	<	690,   692,   694,   696,   698,   700,   702,   704,   706,   708,
1076	<	710,   712,   715,   720,   722,   727,   732,   737,   742,   747,
1077	<	752,   757,   762,   767,   772,   777,   782,   783,   790,   791,
1078	<	797,   801,   803,   805,   807,   809,   812,   814,   816,   818,
1079	<	820,   822,   825,   826,   832,   836,   838,   840,   844,   849,
1080	<	854,   855,   862,   865,   867,   869,   871,   873,   875,   877,
1081	<	879,   881,   883,   885,   887,   889,   891,   893,   895,   897,
1082	<	899,   902,   907,   912,   917,   922,   927,   928,   934,   938,
1083	<	940,   941,   945,   946,   949,   951,   953,   955,   957,   959,
1084	<	961,   963,   965,   967,   969,   974,   979,   984,   989,   994,
1085	<	999,  1004,  1009,  1014,  1019,  1020,  1027,  1030,  1032,  1034,
1086	<	1036,  1038,  1041,  1046,  1051,  1056,  1057,  1064,  1067,  1069,
1087	<	1071,  1073,  1075,  1078,  1083,  1088,  1089,  1095,  1099,  1101,
1088	<	1103,  1105,  1107,  1109,  1111,  1113,  1115,  1117,  1119,  1121,
1089	<	1123,  1124,  1131,  1134,  1136,  1138,  1140,  1143,  1148,  1149,
1090	<	1155,  1159,  1161,  1163,  1165,  1167,  1169,  1171,  1173,  1175,
1091	<	1177,  1179,  1181,  1183,  1184,  1192,  1193,  1195,  1198,  1200,
1092	<	1202,  1204,  1206,  1208,  1210,  1212,  1214,  1216,  1218,  1220,
1093	<	1222,  1224,  1226,  1228,  1230,  1232,  1234,  1236,  1238,  1241,
1094	<	1246,  1248,  1253,  1258,  1263,  1268,  1273,  1278,  1283,  1288,
1095	<	1289,  1295,  1299,  1301,  1302,  1306,  1307,  1310,  1312,  1314,
1096	<	1316,  1318,  1320,  1325,  1330,  1335,  1340,  1345,  1350,  1355,
1097	<	1360,  1365,  1370,  1371,  1378,  1379,  1385,  1389,  1391,  1393,
1098	<	1396,  1398,  1400,  1402,  1404,  1406,  1411,  1416,  1417,  1424,
1099	<	1427,  1429,  1431,  1433,  1435,  1440,  1445,  1451,  1454,  1456,
1100	<	1458,  1460,  1465,  1466,  1473,  1474,  1480,  1484,  1486,  1488,
1101	<	1491,  1493,  1495,  1497,  1499,  1501,  1506,  1511,  1517,  1520,
1102	<	1522,  1524,  1526,  1528,  1530,  1532,  1534,  1536,  1538,  1540,
1103	<	1542,  1544,  1546,  1548,  1550,  1552,  1554,  1556,  1558,  1560,
1104	<	1562,  1564,  1566,  1568,  1570,  1572,  1574,  1576,  1578,  1580,
1105	<	1582,  1584,  1586,  1588,  1590,  1592,  1594,  1596,  1598,  1600,
1106	<	1602,  1604,  1606,  1608,  1610,  1612,  1614,  1616,  1618,  1620,
1107	<	1622,  1624,  1626,  1628,  1630,  1632,  1634,  1636,  1641,  1646,
1108	<	1651,  1656,  1661,  1666,  1671,  1676,  1681,  1686,  1691,  1696,
1109	<	1701,  1706,  1711,  1716,  1721,  1726,  1731,  1736,  1741,  1746,
1110	<	1751,  1756,  1761,  1766,  1771,  1776,  1781,  1786,  1791,  1796,
1111	<	1801,  1806,  1811,  1816,  1821,  1826,  1831,  1836,  1841,  1846,
1112	<	1851,  1856,  1861,  1866,  1871,  1876,  1881,  1886,  1891,  1892,
1113	<	1898,  1902,  1904,  1906,  1908,  1910,  1912,  1914,  1916,  1918,
1114	<	1920,  1922,  1924,  1926,  1928,  1930,  1932,  1934,  1936,  1938,
1115	<	1940,  1942,  1943,  1949,  1953,  1955,  1957,  1959,  1961,  1963,
1116	<	1965,  1967,  1969,  1971,  1973,  1975,  1977,  1979,  1981,  1983,
1117	<	1985,  1987,  1989,  1991,  1993,  1998,  2003,  2008,  2013,  2018,
1118	<	2019,  2026,  2029,  2031,  2033,  2035,  2037,  2039,  2041,  2043,
1119	<	2045,  2050,  2055,  2056,  2062,  2066,  2068,  2070,  2072,  2077,
1120	<	2082,  2083,  2089,  2093,  2095,  2097,  2099,  2105,  2108,  2110,
1121	<	2112,  2114,  2116,  2118,  2120,  2122,  2124,  2126,  2128,  2130,
1122	<	2132,  2134,  2136,  2138,  2140,  2142,  2144,  2146,  2148,  2153,
1123	<	2158,  2163,  2168,  2173,  2178,  2183,  2188,  2193,  2198,  2203,
1124	<	2208,  2213,  2218,  2223,  2228,  2233,  2238,  2244,  2247,  2249,
1125	<	2251,  2253,  2255,  2257,  2259,  2261,  2263,  2265,  2270,  2275,
1126	<	2280,  2285,  2290,  2295
1127	<	};
1128	<
1129	<	/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
1130	<	static const yytype_int16 yyrhs[] =
1088	>	/* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
1089	>	static const yytype_int16 yyrline[] =
1090		{
1091	<	268,     0,    -1,    -1,   268,   269,    -1,   297,    -1,   303,
1092	<	-1,   318,    -1,   582,    -1,   355,    -1,   374,    -1,   388,
1093	<	-1,   279,    -1,   603,    -1,   414,    -1,   421,    -1,   431,
1094	<	-1,   440,    -1,   471,    -1,   481,    -1,   487,    -1,   501,
1095	<	-1,   566,    -1,   491,    -1,   274,    -1,     1,   262,    -1,
1096	<	1,   263,    -1,    -1,   271,    -1,   133,   270,    -1,   133,
1097	<	175,   270,    -1,   133,   176,   270,    -1,   133,   177,   270,
1098	<	-1,   133,   178,   270,    -1,   133,   179,   270,    -1,    -1,
1099	<	273,    -1,   133,   272,    -1,   133,    14,   272,    -1,   133,
1100	<	15,   272,    -1,   133,    16,   272,    -1,   121,   264,   275,
1101	<	263,   262,    -1,   275,   276,    -1,   276,    -1,   277,    -1,
1102	<	278,    -1,     1,   262,    -1,   120,   265,   155,   262,    -1,
1103	<	150,   265,   155,   262,    -1,   183,   264,   280,   263,   262,
1104	<	-1,   280,   281,    -1,   281,    -1,   288,    -1,   293,    -1,
1105	<	296,    -1,   290,    -1,   291,    -1,   292,    -1,   295,    -1,
1106	<	287,    -1,   294,    -1,   289,    -1,   286,    -1,   282,    -1,
1107	<	1,   262,    -1,    -1,   170,   283,   265,   284,   262,    -1,
1108	<	284,   266,   285,    -1,   285,    -1,   171,    -1,   172,    -1,
1109	<	169,   265,   155,   262,    -1,   167,   265,   155,   262,    -1,
1110	<	122,   265,   155,   262,    -1,   185,   265,   155,   262,    -1,
1111	<	37,   265,   155,   262,    -1,   125,   265,   155,   262,    -1,
1112	<	124,   265,   155,   262,    -1,   257,   265,   155,   262,    -1,
1113	<	258,   265,   155,   262,    -1,   229,   265,   133,   262,    -1,
1114	<	86,   265,   199,   262,    -1,     5,   264,   298,   263,   262,
1115	<	-1,   298,   299,    -1,   299,    -1,   300,    -1,   302,    -1,
1116	<	301,    -1,     1,   262,    -1,   122,   265,   155,   262,    -1,
1117	<	48,   265,   155,   262,    -1,    37,   265,   155,   262,    -1,
1118	<	104,   264,   304,   263,   262,    -1,   304,   305,    -1,   305,
1119	<	-1,   306,    -1,   307,    -1,   316,    -1,   317,    -1,   308,
1120	<	-1,   310,    -1,   312,    -1,   313,    -1,   315,    -1,   311,
1121	<	-1,   314,    -1,   309,    -1,     1,   262,    -1,   221,   265,
1122	<	155,   262,    -1,   140,   265,   155,   262,    -1,    64,   265,
1123	<	155,   262,    -1,    57,   265,   155,   262,    -1,    62,   265,
1124	<	155,   262,    -1,    63,   265,   155,   262,    -1,    60,   265,
1125	<	155,   262,    -1,    59,   265,   155,   262,    -1,    61,   265,
1126	<	155,   262,    -1,    58,   265,   155,   262,    -1,   105,   265,
1127	<	222,   262,    -1,   105,   265,   224,   262,    -1,   105,   265,
1128	<	228,   262,    -1,   105,   265,   226,   262,    -1,   105,   265,
1129	<	227,   262,    -1,   105,   265,   225,   262,    -1,   105,   265,
1130	<	223,   262,    -1,   255,   265,   199,   262,    -1,    -1,   138,
1131	<	319,   320,   264,   321,   263,   262,    -1,    -1,   324,    -1,
1132	<	321,   322,    -1,   322,    -1,   323,    -1,   325,    -1,   326,
1133	<	-1,   345,    -1,   346,    -1,   330,    -1,   329,    -1,   334,
1134	<	-1,   335,    -1,   337,    -1,   338,    -1,   339,    -1,   340,
1135	<	-1,   341,    -1,   336,    -1,   342,    -1,   343,    -1,   344,
1136	<	-1,   347,    -1,   327,    -1,   328,    -1,   348,    -1,     1,
1137	<	262,    -1,   122,   265,   155,   262,    -1,   155,    -1,   250,
1138	<	265,   155,   262,    -1,   149,   265,   155,   262,    -1,    50,
1139	<	265,   199,   262,    -1,   168,   265,   155,   262,    -1,    26,
1140	<	265,   155,   262,    -1,    -1,   238,   331,   265,   332,   262,
1141	<	-1,   332,   266,   333,    -1,   333,    -1,   206,    -1,   209,
1142	<	-1,   210,    -1,   212,    -1,   213,    -1,   216,    -1,   235,
1143	<	-1,   230,    -1,   232,    -1,   239,    -1,   236,    -1,   215,
1144	<	-1,   231,    -1,   234,    -1,   217,    -1,   242,    -1,   207,
1145	<	-1,   208,    -1,   220,    -1,    74,   265,   199,   262,    -1,
1146	<	163,   265,   199,   262,    -1,   164,   265,   199,   262,    -1,
1147	<	94,   265,   199,   262,    -1,   259,   265,   199,   262,    -1,
1148	<	249,   265,   199,   262,    -1,    67,   265,   199,   262,    -1,
1149	<	127,   265,   199,   262,    -1,    38,   265,   199,   262,    -1,
1150	<	161,   265,   199,   262,    -1,     5,   265,   199,   262,    -1,
1151	<	79,   265,   199,   262,    -1,    81,   265,   199,   262,    -1,
1152	<	231,   265,   199,   262,    -1,    -1,    55,   349,   265,   350,
1153	<	262,    -1,   350,   266,   351,    -1,   351,    -1,    -1,   132,
1154	<	352,   354,    -1,    -1,   353,   354,    -1,    74,    -1,   163,
1155	<	-1,    94,    -1,   249,    -1,   259,    -1,    67,    -1,    38,
1156	<	-1,   161,    -1,     5,    -1,    79,    -1,   127,    -1,   231,
1157	<	-1,   143,    -1,    81,    -1,   164,    -1,    50,    -1,    -1,
1199	<	26,   356,   357,   264,   358,   263,   262,    -1,    -1,   361,
1200	<	-1,   358,   359,    -1,   359,    -1,   360,    -1,   371,    -1,
1201	<	372,    -1,   362,    -1,   363,    -1,   373,    -1,   364,    -1,
1202	<	365,    -1,   366,    -1,   367,    -1,   368,    -1,   369,    -1,
1203	<	370,    -1,     1,   262,    -1,   122,   265,   155,   262,    -1,
1204	<	155,    -1,   152,   265,   271,   262,    -1,   153,   265,   271,
1205	<	262,    -1,   136,   265,   133,   262,    -1,    30,   265,   271,
1206	<	262,    -1,   114,   265,   133,   262,    -1,   109,   265,   133,
1207	<	262,    -1,   111,   265,   133,   262,    -1,   110,   265,   133,
1208	<	262,    -1,   180,   265,   273,   262,    -1,    23,   265,   133,
1209	<	262,    -1,    24,   265,   133,   262,    -1,   135,   265,   133,
1210	<	262,    -1,    -1,   102,   375,   264,   380,   263,   262,    -1,
1211	<	-1,    55,   377,   265,   378,   262,    -1,   378,   266,   379,
1212	<	-1,   379,    -1,   237,    -1,    78,    -1,   233,    -1,   380,
1213	<	381,    -1,   381,    -1,   382,    -1,   376,    -1,   386,    -1,
1214	<	387,    -1,     1,   262,    -1,    -1,   154,   265,   384,   383,
1215	<	262,    -1,   384,   266,   385,    -1,   385,    -1,   133,    -1,
1216	<	133,   204,   133,    -1,    91,   265,   155,   262,    -1,    85,
1217	<	265,   155,   262,    -1,    -1,    75,   389,   264,   390,   263,
1218	<	262,    -1,   390,   391,    -1,   391,    -1,   392,    -1,   393,
1219	<	-1,   395,    -1,   397,    -1,   404,    -1,   405,    -1,   406,
1220	<	-1,   408,    -1,   409,    -1,   410,    -1,   394,    -1,   411,
1221	<	-1,   412,    -1,   407,    -1,   413,    -1,   396,    -1,     1,
1222	<	262,    -1,   250,   265,   155,   262,    -1,   149,   265,   155,
1223	<	262,    -1,   193,   265,   199,   262,    -1,    26,   265,   155,
1224	<	262,    -1,    50,   265,   199,   262,    -1,    -1,    55,   398,
1225	<	265,   399,   262,    -1,   399,   266,   400,    -1,   400,    -1,
1226	<	-1,   132,   401,   403,    -1,    -1,   402,   403,    -1,   193,
1227	<	-1,    51,    -1,    95,    -1,    76,    -1,    20,    -1,    21,
1228	<	-1,   131,    -1,    69,    -1,   174,    -1,   123,    -1,    95,
1229	<	265,   199,   262,    -1,    76,   265,   199,   262,    -1,    51,
1230	<	265,   199,   262,    -1,    20,   265,   199,   262,    -1,   131,
1231	<	265,   199,   262,    -1,    69,   265,   199,   262,    -1,   192,
1232	<	265,   155,   262,    -1,   159,   265,   155,   262,    -1,   158,
1233	<	265,   133,   262,    -1,   123,   265,   199,   262,    -1,    -1,
1234	<	173,   415,   264,   416,   263,   262,    -1,   416,   417,    -1,
1235	<	417,    -1,   418,    -1,   419,    -1,   420,    -1,     1,   262,
1236	<	-1,   157,   265,   155,   262,    -1,    22,   265,   155,   262,
1237	<	-1,   126,   265,   155,   262,    -1,    -1,   187,   422,   264,
1238	<	423,   263,   262,    -1,   423,   424,    -1,   424,    -1,   425,
1239	<	-1,   426,    -1,   427,    -1,     1,   262,    -1,   122,   265,
1240	<	155,   262,    -1,   250,   265,   155,   262,    -1,    -1,   189,
1241	<	428,   265,   429,   262,    -1,   429,   266,   430,    -1,   430,
1242	<	-1,    94,    -1,   246,    -1,   249,    -1,   259,    -1,   247,
1243	<	-1,   241,    -1,   173,    -1,   248,    -1,   240,    -1,   220,
1244	<	-1,   205,    -1,    -1,   188,   432,   264,   433,   263,   262,
1245	<	-1,   433,   434,    -1,   434,    -1,   435,    -1,   436,    -1,
1246	<	1,   262,    -1,   122,   265,   155,   262,    -1,    -1,   189,
1247	<	437,   265,   438,   262,    -1,   438,   266,   439,    -1,   439,
1248	<	-1,    94,    -1,   246,    -1,   249,    -1,   259,    -1,   247,
1249	<	-1,   241,    -1,   173,    -1,   248,    -1,   240,    -1,   220,
1250	<	-1,   205,    -1,    -1,    29,   441,   442,   264,   443,   263,
1251	<	262,    -1,    -1,   446,    -1,   443,   444,    -1,   444,    -1,
1252	<	445,    -1,   447,    -1,   448,    -1,   449,    -1,   450,    -1,
1253	<	452,    -1,   451,    -1,   453,    -1,   454,    -1,   467,    -1,
1254	<	468,    -1,   469,    -1,   465,    -1,   462,    -1,   464,    -1,
1255	<	463,    -1,   461,    -1,   470,    -1,   466,    -1,     1,   262,
1256	<	-1,   122,   265,   155,   262,    -1,   155,    -1,    85,   265,
1257	<	155,   262,    -1,   257,   265,   155,   262,    -1,   181,   265,
1258	<	155,   262,    -1,     3,   265,   155,   262,    -1,   154,   265,
1259	<	133,   262,    -1,     6,   265,   218,   262,    -1,     6,   265,
1260	<	219,   262,    -1,    54,   265,   155,   262,    -1,    -1,    55,
1261	<	455,   265,   456,   262,    -1,   456,   266,   457,    -1,   457,
1262	<	-1,    -1,   132,   458,   460,    -1,    -1,   459,   460,    -1,
1263	<	27,    -1,    31,    -1,    10,    -1,    12,    -1,   244,    -1,
1264	<	168,   265,   155,   262,    -1,    50,   265,   199,   262,    -1,
1265	<	31,   265,   199,   262,    -1,    27,   265,   199,   262,    -1,
1266	<	10,   265,   199,   262,    -1,   244,   265,   199,   262,    -1,
1267	<	87,   265,   155,   262,    -1,   100,   265,   155,   262,    -1,
1268	<	26,   265,   155,   262,    -1,    25,   265,   155,   262,    -1,
1269	<	-1,    92,   472,   264,   477,   263,   262,    -1,    -1,   189,
1270	<	474,   265,   475,   262,    -1,   475,   266,   476,    -1,   476,
1271	<	-1,   160,    -1,   477,   478,    -1,   478,    -1,   479,    -1,
1272	<	480,    -1,   473,    -1,     1,    -1,   250,   265,   155,   262,
1273	<	-1,   157,   265,   155,   262,    -1,    -1,    36,   482,   264,
1274	<	483,   263,   262,    -1,   483,   484,    -1,   484,    -1,   485,
1275	<	-1,   486,    -1,     1,    -1,    91,   265,   155,   262,    -1,
1276	<	157,   265,   155,   262,    -1,    52,   264,   488,   263,   262,
1277	<	-1,   488,   489,    -1,   489,    -1,   490,    -1,     1,    -1,
1278	<	91,   265,   155,   262,    -1,    -1,    65,   492,   264,   497,
1279	<	263,   262,    -1,    -1,   189,   494,   265,   495,   262,    -1,
1280	<	495,   266,   496,    -1,   496,    -1,   160,    -1,   497,   498,
1281	<	-1,   498,    -1,   499,    -1,   500,    -1,   493,    -1,     1,
1282	<	-1,   122,   265,   155,   262,    -1,   157,   265,   155,   262,
1283	<	-1,    66,   264,   502,   263,   262,    -1,   502,   503,    -1,
1284	<	503,    -1,   512,    -1,   513,    -1,   515,    -1,   516,    -1,
1285	<	517,    -1,   518,    -1,   519,    -1,   520,    -1,   521,    -1,
1286	<	522,    -1,   511,    -1,   524,    -1,   525,    -1,   526,    -1,
1287	<	527,    -1,   543,    -1,   529,    -1,   531,    -1,   533,    -1,
1288	<	532,    -1,   536,    -1,   530,    -1,   537,    -1,   538,    -1,
1289	<	539,    -1,   540,    -1,   542,    -1,   541,    -1,   557,    -1,
1290	<	544,    -1,   548,    -1,   549,    -1,   553,    -1,   534,    -1,
1291	<	535,    -1,   563,    -1,   561,    -1,   562,    -1,   545,    -1,
1292	<	514,    -1,   546,    -1,   547,    -1,   564,    -1,   552,    -1,
1293	<	523,    -1,   565,    -1,   550,    -1,   551,    -1,   507,    -1,
1294	<	510,    -1,   505,    -1,   506,    -1,   508,    -1,   509,    -1,
1295	<	528,    -1,   504,    -1,     1,    -1,   116,   265,   133,   262,
1296	<	-1,    72,   265,   133,   262,    -1,    73,   265,   133,   262,
1297	<	-1,    12,   265,   199,   262,    -1,   256,   265,   199,   262,
1298	<	-1,   162,   265,   271,   262,    -1,   186,   265,   199,   262,
1299	<	-1,    93,   265,   133,   262,    -1,    84,   265,   199,   262,
1300	<	-1,    89,   265,   199,   262,    -1,    43,   265,   199,   262,
1301	<	-1,    53,   265,   199,   262,    -1,     8,   265,   199,   262,
1302	<	-1,   113,   265,   271,   262,    -1,   112,   265,   133,   262,
1303	<	-1,   106,   265,   133,   262,    -1,     9,   265,   271,   262,
1304	<	-1,   203,   265,   271,   262,    -1,   202,   265,   271,   262,
1305	<	-1,    77,   265,   133,   262,    -1,    97,   265,   199,   262,
1306	<	-1,    96,   265,   155,   262,    -1,    90,   265,   199,   262,
1307	<	-1,   261,   265,   199,   262,    -1,   194,   265,   199,   262,
1308	<	-1,   197,   265,   199,   262,    -1,   198,   265,   199,   262,
1309	<	-1,   196,   265,   199,   262,    -1,   196,   265,   200,   262,
1310	<	-1,   195,   265,   199,   262,    -1,   195,   265,   200,   262,
1311	<	-1,   147,   265,   271,   262,    -1,    19,   265,   271,   262,
1312	<	-1,   139,   265,   199,   262,    -1,   148,   265,   271,   262,
1313	<	-1,   190,   265,   199,   262,    -1,   130,   265,   199,   262,
1314	<	-1,   245,   265,   199,   262,    -1,   142,   265,   199,   262,
1315	<	-1,   117,   265,   155,   262,    -1,    88,   265,   271,   262,
1316	<	-1,    45,   265,   133,   262,    -1,   115,   265,   133,   262,
1317	<	-1,   184,   265,   155,   262,    -1,    32,   265,   155,   262,
1318	<	-1,    28,   265,   133,   262,    -1,   251,   265,   199,   262,
1319	<	-1,    47,   265,   155,   262,    -1,   151,   265,   199,   262,
1320	<	-1,    39,   265,   199,   262,    -1,   243,   265,   271,   262,
1321	<	-1,    -1,   144,   554,   265,   555,   262,    -1,   555,   266,
1322	<	556,    -1,   556,    -1,   206,    -1,   209,    -1,   210,    -1,
1323	<	212,    -1,   213,    -1,   216,    -1,   235,    -1,   230,    -1,
1324	<	232,    -1,   239,    -1,   236,    -1,   215,    -1,   231,    -1,
1325	<	234,    -1,   217,    -1,   242,    -1,   207,    -1,   208,    -1,
1326	<	220,    -1,    -1,   141,   558,   265,   559,   262,    -1,   559,
1327	<	266,   560,    -1,   560,    -1,   206,    -1,   209,    -1,   210,
1328	<	-1,   212,    -1,   213,    -1,   216,    -1,   235,    -1,   230,
1329	<	-1,   232,    -1,   239,    -1,   236,    -1,   215,    -1,   231,
1330	<	-1,   234,    -1,   217,    -1,   242,    -1,   207,    -1,   208,
1331	<	-1,   220,    -1,   118,   265,   133,   262,    -1,   119,   265,
1332	<	133,   262,    -1,    33,   265,   133,   262,    -1,   211,   265,
1333	<	273,   262,    -1,    44,   265,   199,   262,    -1,    -1,    68,
1334	<	567,   264,   568,   263,   262,    -1,   568,   569,    -1,   569,
1335	<	-1,   570,    -1,   571,    -1,   572,    -1,   576,    -1,   577,
1336	<	-1,   578,    -1,     1,    -1,    49,   265,   199,   262,    -1,
1337	<	46,   265,   271,   262,    -1,    -1,   104,   573,   265,   574,
1338	<	262,    -1,   574,   266,   575,    -1,   575,    -1,   201,    -1,
1339	<	11,    -1,   250,   265,   155,   262,    -1,   122,   265,   155,
1340	<	262,    -1,    -1,     4,   579,   265,   580,   262,    -1,   580,
1341	<	266,   581,    -1,   581,    -1,   201,    -1,    11,    -1,    22,
1342	<	264,   583,   263,   262,    -1,   583,   584,    -1,   584,    -1,
1343	<	587,    -1,   588,    -1,   589,    -1,   590,    -1,   595,    -1,
1344	<	591,    -1,   592,    -1,   593,    -1,   594,    -1,   596,    -1,
1345	<	597,    -1,   598,    -1,   586,    -1,   599,    -1,   600,    -1,
1346	<	601,    -1,   602,    -1,   585,    -1,     1,    -1,    40,   265,
1347	<	199,   262,    -1,   165,   265,   199,   262,    -1,    42,   265,
1348	<	199,   262,    -1,   252,   265,   199,   262,    -1,   253,   265,
1349	<	199,   262,    -1,   254,   265,   199,   262,    -1,    98,   265,
1350	<	271,   262,    -1,    99,   265,   271,   262,    -1,   108,   265,
1351	<	133,   262,    -1,   156,   265,   199,   262,    -1,   107,   265,
1352	<	133,   262,    -1,    35,   265,   133,   262,    -1,    34,   265,
1353	<	133,   262,    -1,   128,   265,   199,   262,    -1,   129,   265,
1354	<	199,   262,    -1,    13,   265,   199,   262,    -1,   145,   265,
1355	<	133,   262,    -1,   146,   265,   271,   262,    -1,   182,   264,
1356	<	604,   263,   262,    -1,   604,   605,    -1,   605,    -1,   606,
1357	<	-1,   607,    -1,   609,    -1,   611,    -1,   610,    -1,   608,
1358	<	-1,   612,    -1,     1,    -1,    56,   265,   199,   262,    -1,
1359	<	83,   265,   199,   262,    -1,    80,   265,   155,   262,    -1,
1360	<	101,   265,   271,   262,    -1,    78,   265,   199,   262,    -1,
1361	<	41,   265,   199,   262,    -1,    82,   265,   199,   262,    -1
1362	<	};
1363	<
1364	<	/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
1365	<	static const yytype_uint16 yyrline[] =
1366	<	{
1367	<	0,   397,   397,   398,   401,   402,   403,   404,   405,   406,
1368	<	407,   408,   409,   410,   411,   412,   413,   414,   415,   416,
1369	<	417,   418,   419,   420,   421,   422,   426,   426,   427,   431,
1370	<	435,   439,   443,   447,   453,   453,   454,   455,   456,   457,
1371	<	464,   467,   467,   468,   468,   468,   470,   478,   487,   489,
1372	<	489,   490,   490,   491,   491,   492,   492,   493,   494,   494,
1373	<	495,   495,   496,   497,   501,   500,   519,   519,   520,   526,
1374	<	534,   568,   628,   642,   657,   666,   680,   689,   717,   747,
1375	<	770,   792,   794,   794,   795,   795,   796,   796,   798,   807,
1376	<	816,   829,   831,   832,   834,   834,   835,   836,   836,   837,
1377	<	837,   838,   838,   839,   839,   840,   841,   843,   847,   851,
1378	<	858,   865,   872,   879,   886,   893,   900,   907,   911,   915,
1379	<	919,   923,   927,   931,   937,   947,   946,  1040,  1040,  1041,
1380	<	1041,  1042,  1042,  1042,  1042,  1043,  1043,  1044,  1044,  1044,
1381	<	1045,  1045,  1045,  1046,  1046,  1046,  1047,  1047,  1047,  1047,
1382	<	1048,  1048,  1049,  1049,  1051,  1063,  1075,  1109,  1121,  1132,
1383	<	1174,  1184,  1183,  1189,  1189,  1190,  1194,  1198,  1202,  1206,
1384	<	1210,  1214,  1218,  1222,  1226,  1230,  1234,  1238,  1242,  1246,
1385	<	1250,  1254,  1258,  1262,  1268,  1279,  1290,  1301,  1312,  1323,
1386	<	1334,  1345,  1356,  1367,  1378,  1389,  1400,  1411,  1423,  1422,
1387	<	1426,  1426,  1427,  1427,  1428,  1428,  1430,  1437,  1444,  1451,
1388	<	1458,  1465,  1472,  1479,  1486,  1493,  1500,  1507,  1514,  1521,
1389	<	1528,  1535,  1549,  1548,  1598,  1598,  1600,  1600,  1601,  1602,
1390	<	1602,  1603,  1604,  1605,  1606,  1607,  1608,  1609,  1610,  1611,
1391	<	1612,  1613,  1615,  1624,  1633,  1639,  1645,  1651,  1657,  1663,
1392	<	1669,  1675,  1681,  1687,  1693,  1699,  1709,  1708,  1725,  1724,
1393	<	1729,  1729,  1730,  1734,  1738,  1746,  1746,  1747,  1747,  1747,
1394	<	1747,  1747,  1749,  1749,  1751,  1751,  1753,  1767,  1787,  1796,
1395	<	1809,  1808,  1877,  1877,  1878,  1878,  1878,  1878,  1879,  1879,
1396	<	1880,  1880,  1880,  1881,  1881,  1882,  1882,  1882,  1883,  1883,
1397	<	1883,  1885,  1922,  1935,  1946,  1955,  1967,  1966,  1970,  1970,
1398	<	1971,  1971,  1972,  1972,  1974,  1982,  1989,  1996,  2003,  2010,
1399	<	2017,  2024,  2031,  2038,  2047,  2058,  2069,  2080,  2091,  2102,
1400	<	2114,  2133,  2143,  2152,  2168,  2167,  2183,  2183,  2184,  2184,
1401	<	2184,  2184,  2186,  2195,  2210,  2224,  2223,  2239,  2239,  2240,
1402	<	2240,  2240,  2240,  2242,  2251,  2274,  2273,  2279,  2279,  2280,
1403	<	2284,  2288,  2292,  2296,  2300,  2304,  2308,  2312,  2316,  2320,
1404	<	2330,  2329,  2346,  2346,  2347,  2347,  2347,  2349,  2356,  2355,
1405	<	2361,  2361,  2362,  2366,  2370,  2374,  2378,  2382,  2386,  2390,
1406	<	2394,  2398,  2402,  2412,  2411,  2557,  2557,  2558,  2558,  2559,
1407	<	2559,  2559,  2560,  2560,  2561,  2561,  2562,  2562,  2562,  2563,
1408	<	2563,  2563,  2564,  2564,  2564,  2565,  2565,  2566,  2566,  2568,
1409	<	2580,  2592,  2601,  2627,  2645,  2663,  2669,  2673,  2681,  2691,
1410	<	2690,  2694,  2694,  2695,  2695,  2696,  2696,  2698,  2709,  2716,
1411	<	2723,  2730,  2740,  2781,  2792,  2803,  2818,  2829,  2840,  2853,
1412	<	2866,  2875,  2911,  2910,  2974,  2973,  2977,  2977,  2978,  2984,
1413	<	2984,  2985,  2985,  2985,  2985,  2987,  3006,  3016,  3015,  3038,
1414	<	3038,  3039,  3039,  3039,  3041,  3047,  3056,  3058,  3058,  3059,
1415	<	3059,  3061,  3080,  3079,  3127,  3126,  3130,  3130,  3131,  3137,
1416	<	3137,  3138,  3138,  3138,  3138,  3140,  3146,  3155,  3158,  3158,
1417	<	3159,  3159,  3160,  3160,  3161,  3161,  3162,  3162,  3163,  3163,
1418	<	3164,  3164,  3165,  3165,  3166,  3166,  3167,  3167,  3168,  3168,
1419	<	3169,  3169,  3170,  3170,  3171,  3171,  3172,  3172,  3173,  3173,
1420	<	3174,  3174,  3175,  3175,  3176,  3176,  3177,  3177,  3178,  3178,
1421	<	3179,  3180,  3180,  3181,  3181,  3182,  3182,  3183,  3183,  3184,
1422	<	3184,  3185,  3185,  3186,  3186,  3187,  3188,  3191,  3196,  3201,
1423	<	3206,  3211,  3216,  3221,  3226,  3231,  3236,  3241,  3246,  3251,
1424	<	3256,  3261,  3266,  3271,  3276,  3281,  3287,  3298,  3303,  3312,
1425	<	3317,  3322,  3327,  3332,  3337,  3340,  3345,  3348,  3353,  3358,
1426	<	3363,  3368,  3373,  3378,  3383,  3388,  3393,  3404,  3409,  3414,
1427	<	3419,  3428,  3460,  3478,  3483,  3492,  3497,  3502,  3508,  3507,
1428	<	3512,  3512,  3513,  3516,  3519,  3522,  3525,  3528,  3531,  3534,
1429	<	3537,  3540,  3543,  3546,  3549,  3552,  3555,  3558,  3561,  3564,
1430	<	3567,  3573,  3572,  3577,  3577,  3578,  3581,  3584,  3587,  3590,
1431	<	3593,  3596,  3599,  3602,  3605,  3608,  3611,  3614,  3617,  3620,
1432	<	3623,  3626,  3629,  3632,  3637,  3642,  3647,  3652,  3657,  3666,
1433	<	3665,  3689,  3689,  3690,  3691,  3692,  3693,  3694,  3695,  3696,
1434	<	3698,  3704,  3711,  3710,  3715,  3715,  3716,  3720,  3726,  3760,
1435	<	3770,  3769,  3819,  3819,  3820,  3824,  3833,  3836,  3836,  3837,
1436	<	3837,  3838,  3838,  3839,  3839,  3840,  3840,  3841,  3841,  3842,
1437	<	3843,  3843,  3844,  3844,  3845,  3845,  3846,  3846,  3848,  3853,
1438	<	3858,  3863,  3868,  3873,  3878,  3883,  3888,  3893,  3898,  3903,
1439	<	3908,  3913,  3918,  3923,  3928,  3933,  3941,  3944,  3944,  3945,
1440	<	3945,  3946,  3947,  3948,  3948,  3949,  3950,  3952,  3958,  3964,
1441	<	3973,  3987,  3993,  3999
1091	>	0,   366,   366,   367,   370,   371,   372,   373,   374,   375,
1092	>	376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
1093	>	386,   387,   388,   389,   390,   391,   392,   393,   397,   397,
1094	>	398,   399,   400,   401,   402,   403,   404,   405,   408,   408,
1095	>	409,   410,   411,   412,   419,   421,   421,   422,   422,   422,
1096	>	424,   430,   440,   442,   442,   443,   444,   445,   446,   447,
1097	>	448,   449,   450,   451,   452,   453,   454,   455,   456,   457,
1098	>	458,   459,   462,   471,   480,   489,   498,   507,   516,   525,
1099	>	540,   555,   565,   579,   588,   611,   634,   657,   667,   669,
1100	>	669,   670,   671,   672,   673,   675,   684,   693,   707,   706,
1101	>	724,   724,   725,   725,   725,   727,   733,   744,   743,   762,
1102	>	762,   763,   763,   763,   763,   763,   765,   771,   777,   783,
1103	>	805,   806,   806,   808,   808,   809,   811,   818,   818,   831,
1104	>	832,   834,   834,   835,   835,   837,   845,   848,   854,   853,
1105	>	859,   859,   860,   864,   868,   872,   876,   880,   884,   888,
1106	>	899,   898,   961,   961,   962,   963,   964,   965,   966,   967,
1107	>	968,   969,   970,   971,   972,   974,   980,   986,   992,   998,
1108	>	1009,  1015,  1026,  1033,  1032,  1038,  1038,  1039,  1043,  1047,
1109	>	1051,  1055,  1059,  1063,  1067,  1071,  1075,  1079,  1083,  1087,
1110	>	1091,  1095,  1099,  1103,  1107,  1111,  1115,  1119,  1123,  1130,
1111	>	1129,  1135,  1135,  1136,  1140,  1144,  1148,  1152,  1156,  1160,
1112	>	1164,  1168,  1172,  1176,  1180,  1184,  1188,  1192,  1196,  1200,
1113	>	1204,  1208,  1212,  1216,  1220,  1224,  1228,  1232,  1236,  1240,
1114	>	1244,  1248,  1259,  1258,  1314,  1314,  1315,  1316,  1317,  1318,
1115	>	1319,  1320,  1321,  1322,  1323,  1324,  1325,  1326,  1327,  1328,
1116	>	1329,  1330,  1332,  1338,  1344,  1350,  1356,  1362,  1368,  1374,
1117	>	1380,  1387,  1393,  1399,  1405,  1414,  1424,  1423,  1429,  1429,
1118	>	1430,  1434,  1445,  1444,  1451,  1450,  1455,  1455,  1456,  1460,
1119	>	1464,  1468,  1472,  1478,  1478,  1479,  1479,  1479,  1479,  1479,
1120	>	1481,  1481,  1483,  1483,  1485,  1498,  1515,  1521,  1532,  1531,
1121	>	1578,  1578,  1579,  1580,  1581,  1582,  1583,  1584,  1585,  1586,
1122	>	1587,  1589,  1595,  1601,  1607,  1619,  1618,  1624,  1624,  1625,
1123	>	1629,  1633,  1637,  1641,  1645,  1649,  1653,  1657,  1663,  1677,
1124	>	1686,  1700,  1699,  1714,  1714,  1715,  1715,  1715,  1715,  1717,
1125	>	1723,  1729,  1739,  1741,  1741,  1742,  1742,  1744,  1761,  1760,
1126	>	1783,  1783,  1784,  1784,  1784,  1784,  1786,  1792,  1812,  1811,
1127	>	1817,  1817,  1818,  1822,  1826,  1830,  1834,  1838,  1842,  1846,
1128	>	1850,  1854,  1865,  1864,  1883,  1883,  1884,  1884,  1884,  1886,
1129	>	1893,  1892,  1898,  1898,  1899,  1903,  1907,  1911,  1915,  1919,
1130	>	1923,  1927,  1931,  1935,  1946,  1945,  2023,  2023,  2024,  2025,
1131	>	2026,  2027,  2028,  2029,  2030,  2031,  2032,  2033,  2034,  2035,
1132	>	2036,  2037,  2038,  2039,  2041,  2047,  2053,  2059,  2065,  2078,
1133	>	2091,  2097,  2103,  2107,  2114,  2113,  2118,  2118,  2119,  2123,
1134	>	2129,  2140,  2146,  2152,  2158,  2174,  2173,  2197,  2197,  2198,
1135	>	2198,  2198,  2200,  2220,  2231,  2230,  2255,  2255,  2256,  2256,
1136	>	2256,  2258,  2264,  2274,  2276,  2276,  2277,  2277,  2279,  2297,
1137	>	2296,  2317,  2317,  2318,  2318,  2318,  2320,  2326,  2336,  2338,
1138	>	2338,  2339,  2340,  2341,  2342,  2343,  2344,  2345,  2346,  2347,
1139	>	2348,  2349,  2350,  2351,  2352,  2353,  2354,  2355,  2356,  2357,
1140	>	2358,  2359,  2360,  2361,  2362,  2363,  2364,  2365,  2366,  2367,
1141	>	2368,  2369,  2370,  2371,  2372,  2373,  2374,  2375,  2376,  2377,
1142	>	2378,  2379,  2380,  2381,  2382,  2383,  2384,  2387,  2392,  2397,
1143	>	2402,  2407,  2412,  2417,  2422,  2427,  2432,  2437,  2442,  2447,
1144	>	2452,  2457,  2462,  2467,  2472,  2477,  2482,  2487,  2492,  2497,
1145	>	2502,  2507,  2512,  2517,  2522,  2527,  2532,  2537,  2542,  2547,
1146	>	2552,  2557,  2562,  2567,  2572,  2577,  2583,  2582,  2587,  2587,
1147	>	2588,  2591,  2594,  2597,  2600,  2603,  2606,  2609,  2612,  2615,
1148	>	2618,  2621,  2624,  2627,  2630,  2633,  2636,  2639,  2642,  2645,
1149	>	2648,  2651,  2657,  2656,  2661,  2661,  2662,  2665,  2668,  2671,
1150	>	2674,  2677,  2680,  2683,  2686,  2689,  2692,  2695,  2698,  2701,
1151	>	2704,  2707,  2710,  2713,  2716,  2719,  2724,  2729,  2734,  2739,
1152	>	2748,  2750,  2750,  2751,  2752,  2753,  2754,  2755,  2756,  2757,
1153	>	2758,  2759,  2760,  2761,  2762,  2763,  2764,  2765,  2766,  2768,
1154	>	2773,  2778,  2783,  2788,  2793,  2798,  2803,  2808,  2813,  2818,
1155	>	2823,  2828,  2833,  2838,  2847,  2849,  2849,  2850,  2851,  2852,
1156	>	2853,  2854,  2855,  2856,  2857,  2858,  2859,  2861,  2867,  2883,
1157	>	2892,  2898,  2904,  2910,  2919,  2925
1158		};
1159		#endif
1160
1161	<	#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1161	>	#if YYDEBUG || YYERROR_VERBOSE || 0
1162		/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1163		First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
1164		static const char *const yytname[] =
1165		{
1166	<	"$end", "error", "$undefined", "ACCEPT_PASSWORD", "ACTION", "ADMIN",
1167	<	"AFTYPE", "T_ALLOW", "ANTI_NICK_FLOOD", "ANTI_SPAM_EXIT_MESSAGE_TIME",
1168	<	"AUTOCONN", "T_BLOCK", "BURST_AWAY", "BURST_TOPICWHO", "BYTES", "KBYTES",
1169	<	"MBYTES", "GBYTES", "TBYTES", "CALLER_ID_WAIT", "CAN_FLOOD", "CAN_IDLE",
1170	<	"CHANNEL", "CIDR_BITLEN_IPV4", "CIDR_BITLEN_IPV6", "CIPHER_PREFERENCE",
1171	<	"CLASS", "COMPRESSED", "COMPRESSION_LEVEL", "CONNECT", "CONNECTFREQ",
1172	<	"CRYPTLINK", "DEFAULT_CIPHER_PREFERENCE", "DEFAULT_FLOODCOUNT",
1173	<	"DEFAULT_SPLIT_SERVER_COUNT", "DEFAULT_SPLIT_USER_COUNT", "DENY",
1174	<	"DESCRIPTION", "DIE", "DISABLE_AUTH", "DISABLE_FAKE_CHANNELS",
1175	<	"DISABLE_HIDDEN", "DISABLE_LOCAL_CHANNELS", "DISABLE_REMOTE_COMMANDS",
1176	<	"DOT_IN_IP6_ADDR", "DOTS_IN_IDENT", "DURATION", "EGDPOOL_PATH", "EMAIL",
1177	<	"ENABLE", "ENCRYPTED", "EXCEED_LIMIT", "EXEMPT", "FAILED_OPER_NOTICE",
1178	<	"FAKENAME", "IRCD_FLAGS", "FLATTEN_LINKS", "FFAILED_OPERLOG", "FKILLLOG",
1179	<	"FKLINELOG", "FGLINELOG", "FIOERRLOG", "FOPERLOG", "FOPERSPYLOG",
1180	<	"FUSERLOG", "GECOS", "GENERAL", "GLINE", "GLINES", "GLINE_EXEMPT",
1181	<	"GLINE_LOG", "GLINE_TIME", "GLINE_MIN_CIDR", "GLINE_MIN_CIDR6",
1182	<	"GLOBAL_KILL", "IRCD_AUTH", "NEED_IDENT", "HAVENT_READ_CONF", "HIDDEN",
1183	<	"HIDDEN_ADMIN", "HIDDEN_NAME", "HIDDEN_OPER", "HIDE_SERVER_IPS",
1184	<	"HIDE_SERVERS", "HIDE_SPOOF_IPS", "HOST", "HUB", "HUB_MASK", "IDLETIME",
1185	<	"IGNORE_BOGUS_TS", "INVISIBLE_ON_CONNECT", "IP", "KILL",
1186	<	"KILL_CHASE_TIME_LIMIT", "KLINE", "KLINE_EXEMPT", "KLINE_REASON",
1187	<	"KLINE_WITH_REASON", "KNOCK_DELAY", "KNOCK_DELAY_CHANNEL", "LEAF_MASK",
1188	<	"LINKS_DELAY", "LISTEN", "T_LOG", "LOGGING", "LOG_LEVEL", "MAX_ACCEPT",
1189	<	"MAX_BANS", "MAX_CHANS_PER_USER", "MAX_GLOBAL", "MAX_IDENT", "MAX_LOCAL",
1190	<	"MAX_NICK_CHANGES", "MAX_NICK_TIME", "MAX_NUMBER", "MAX_TARGETS",
1191	<	"MAX_WATCH", "MESSAGE_LOCALE", "MIN_NONWILDCARD",
1192	<	"MIN_NONWILDCARD_SIMPLE", "MODULE", "MODULES", "NAME", "NEED_PASSWORD",
1193	<	"NETWORK_DESC", "NETWORK_NAME", "NICK", "NICK_CHANGES",
1194	<	"NO_CREATE_ON_SPLIT", "NO_JOIN_ON_SPLIT", "NO_OPER_FLOOD", "NO_TILDE",
1195	<	"NOT", "NUMBER", "NUMBER_PER_IDENT", "NUMBER_PER_CIDR", "NUMBER_PER_IP",
1196	<	"NUMBER_PER_IP_GLOBAL", "OPERATOR", "OPERS_BYPASS_CALLERID", "OPER_LOG",
1197	<	"OPER_ONLY_UMODES", "OPER_PASS_RESV", "OPER_SPY_T", "OPER_UMODES",
1198	<	"JOIN_FLOOD_COUNT", "JOIN_FLOOD_TIME", "PACE_WAIT", "PACE_WAIT_SIMPLE",
1199	<	"PASSWORD", "PATH", "PING_COOKIE", "PING_TIME", "PING_WARNING", "PORT",
1200	<	"QSTRING", "QUIET_ON_BAN", "REASON", "REDIRPORT", "REDIRSERV", "REGEX_T",
1201	<	"REHASH", "TREJECT_HOLD_TIME", "REMOTE", "REMOTEBAN",
1202	<	"RESTRICT_CHANNELS", "RESTRICTED", "RSA_PRIVATE_KEY_FILE",
1203	<	"RSA_PUBLIC_KEY_FILE", "SSL_CERTIFICATE_FILE", "T_SSL_CONNECTION_METHOD",
1204	<	"T_SSLV3", "T_TLSV1", "RESV", "RESV_EXEMPT", "SECONDS", "MINUTES",
1205	<	"HOURS", "DAYS", "WEEKS", "SENDQ", "SEND_PASSWORD", "SERVERHIDE",
1206	<	"SERVERINFO", "SERVLINK_PATH", "IRCD_SID", "TKLINE_EXPIRE_NOTICES",
1207	<	"T_SHARED", "T_CLUSTER", "TYPE", "SHORT_MOTD", "SILENT", "SPOOF",
1208	<	"SPOOF_NOTICE", "STATS_E_DISABLED", "STATS_I_OPER_ONLY",
1209	<	"STATS_K_OPER_ONLY", "STATS_O_OPER_ONLY", "STATS_P_OPER_ONLY", "TBOOL",
1210	<	"TMASKED", "T_REJECT", "TS_MAX_DELTA", "TS_WARN_DELTA", "TWODOTS",
1211	<	"T_ALL", "T_BOTS", "T_SOFTCALLERID", "T_CALLERID", "T_CCONN",
1212	<	"T_CCONN_FULL", "T_CLIENT_FLOOD", "T_DEAF", "T_DEBUG", "T_DRONE",
1213	<	"T_EXTERNAL", "T_FULL", "T_INVISIBLE", "T_IPV4", "T_IPV6", "T_LOCOPS",
1214	<	"T_LOGPATH", "T_L_CRIT", "T_L_DEBUG", "T_L_ERROR", "T_L_INFO",
1215	<	"T_L_NOTICE", "T_L_TRACE", "T_L_WARN", "T_MAX_CLIENTS", "T_NCHANGE",
1216	<	"T_OPERWALL", "T_REJ", "T_SERVER", "T_SERVNOTICE", "T_SKILL", "T_SPY",
1217	<	"T_SSL", "T_UMODES", "T_UNAUTH", "T_UNRESV", "T_UNXLINE", "T_WALLOP",
1218	<	"THROTTLE_TIME", "TOPICBURST", "TRUE_NO_OPER_FLOOD", "TKLINE", "TXLINE",
1219	<	"TRESV", "UNKLINE", "USER", "USE_EGD", "USE_EXCEPT", "USE_INVEX",
1220	<	"USE_KNOCK", "USE_LOGGING", "USE_WHOIS_ACTUALLY", "VHOST", "VHOST6",
1221	<	"XLINE", "WARN", "WARN_NO_NLINE", "';'", "'}'", "'{'", "'='", "','",
1222	<	"$accept", "conf", "conf_item", "timespec_", "timespec", "sizespec_",
1223	<	"sizespec", "modules_entry", "modules_items", "modules_item",
1224	<	"modules_module", "modules_path", "serverinfo_entry", "serverinfo_items",
1225	<	"serverinfo_item", "serverinfo_ssl_connection_method", "$@1",
1226	<	"method_types", "method_type_item", "serverinfo_ssl_certificate_file",
1511	<	"serverinfo_rsa_private_key_file", "serverinfo_name", "serverinfo_sid",
1166	>	"$end", "error", "$undefined", "ACCEPT_PASSWORD", "ADMIN", "AFTYPE",
1167	>	"ANTI_NICK_FLOOD", "ANTI_SPAM_EXIT_MESSAGE_TIME", "AUTOCONN",
1168	>	"AWAY_COUNT", "AWAY_TIME", "BOT", "BYTES", "KBYTES", "MBYTES",
1169	>	"CALLER_ID_WAIT", "CAN_FLOOD", "CHANNEL", "CIDR_BITLEN_IPV4",
1170	>	"CIDR_BITLEN_IPV6", "CLASS", "CLIENT", "CLOSE", "CONNECT", "CONNECTFREQ",
1171	>	"CYCLE_ON_HOST_CHANGE", "DEFAULT_FLOODCOUNT", "DEFAULT_FLOODTIME",
1172	>	"DEFAULT_JOIN_FLOOD_COUNT", "DEFAULT_JOIN_FLOOD_TIME",
1173	>	"DEFAULT_MAX_CLIENTS", "DEFER", "DENY", "DESCRIPTION", "DIE",
1174	>	"DISABLE_AUTH", "DISABLE_FAKE_CHANNELS", "DISABLE_REMOTE_COMMANDS",
1175	>	"DLINE_MIN_CIDR", "DLINE_MIN_CIDR6", "DOTS_IN_IDENT", "EMAIL",
1176	>	"ENABLE_EXTBANS", "ENCRYPTED", "EXCEED_LIMIT", "EXEMPT", "EXPIRATION",
1177	>	"FAILED_OPER_NOTICE", "FLATTEN_LINKS", "FLATTEN_LINKS_DELAY",
1178	>	"FLATTEN_LINKS_FILE", "GECOS", "GENERAL", "HIDDEN", "HIDDEN_NAME",
1179	>	"HIDE_CHANS", "HIDE_IDLE", "HIDE_IDLE_FROM_OPERS", "HIDE_SERVER_IPS",
1180	>	"HIDE_SERVERS", "HIDE_SERVICES", "HOST", "HUB", "HUB_MASK",
1181	>	"INVISIBLE_ON_CONNECT", "INVITE_CLIENT_COUNT", "INVITE_CLIENT_TIME",
1182	>	"INVITE_DELAY_CHANNEL", "INVITE_EXPIRE_TIME", "IP", "IRCD_AUTH",
1183	>	"IRCD_FLAGS", "IRCD_SID", "JOIN", "KILL", "KILL_CHASE_TIME_LIMIT",
1184	>	"KLINE", "KLINE_EXEMPT", "KLINE_MIN_CIDR", "KLINE_MIN_CIDR6",
1185	>	"KNOCK_CLIENT_COUNT", "KNOCK_CLIENT_TIME", "KNOCK_DELAY_CHANNEL",
1186	>	"LEAF_MASK", "LISTEN", "MASK", "MAX_ACCEPT", "MAX_BANS",
1187	>	"MAX_BANS_LARGE", "MAX_CHANNELS", "MAX_IDLE", "MAX_INVITES",
1188	>	"MAX_MONITOR", "MAX_NICK_CHANGES", "MAX_NICK_LENGTH", "MAX_NICK_TIME",
1189	>	"MAX_NUMBER", "MAX_TARGETS", "MAX_TOPIC_LENGTH", "MIN_IDLE",
1190	>	"MIN_NONWILDCARD", "MIN_NONWILDCARD_SIMPLE", "MODULE", "MODULES", "MOTD",
1191	>	"NAME", "NEED_IDENT", "NEED_PASSWORD", "NETWORK_DESCRIPTION",
1192	>	"NETWORK_NAME", "NICK", "NO_OPER_FLOOD", "NO_TILDE", "NUMBER_PER_CIDR",
1193	>	"NUMBER_PER_IP_GLOBAL", "NUMBER_PER_IP_LOCAL", "OPER_ONLY_UMODES",
1194	>	"OPER_UMODES", "OPERATOR", "OPERS_BYPASS_CALLERID", "PACE_WAIT",
1195	>	"PACE_WAIT_SIMPLE", "PASSWORD", "PATH", "PING_COOKIE", "PING_TIME",
1196	>	"PORT", "RANDOM_IDLE", "REASON", "REDIRPORT", "REDIRSERV", "REHASH",
1197	>	"REMOTE", "REMOTEBAN", "RESV", "RESV_EXEMPT", "RSA_PRIVATE_KEY_FILE",
1198	>	"SECONDS", "MINUTES", "HOURS", "DAYS", "WEEKS", "MONTHS", "YEARS",
1199	>	"SEND_PASSWORD", "SENDQ", "SERVERHIDE", "SERVERINFO", "SHORT_MOTD",
1200	>	"SPOOF", "SQUIT", "STATS_E_DISABLED", "STATS_I_OPER_ONLY",
1201	>	"STATS_K_OPER_ONLY", "STATS_M_OPER_ONLY", "STATS_O_OPER_ONLY",
1202	>	"STATS_P_OPER_ONLY", "STATS_U_OPER_ONLY", "T_ALL", "T_BIND",
1203	>	"T_CALLERID", "T_CCONN", "T_COMMAND", "T_CLUSTER", "T_DEAF", "T_DEBUG",
1204	>	"T_DLINE", "T_EXTERNAL", "T_FARCONNECT", "T_FILE", "T_FLOOD",
1205	>	"T_GLOBOPS", "T_INVISIBLE", "T_IPV4", "T_IPV6", "T_LOCOPS", "T_LOG",
1206	>	"T_NCHANGE", "T_NONONREG", "T_OPME", "T_PREPEND", "T_PSEUDO", "T_RECVQ",
1207	>	"T_REJ", "T_RESTART", "T_SERVER", "T_SERVICE", "T_SERVNOTICE", "T_SET",
1208	>	"T_SHARED", "T_SIZE", "T_SKILL", "T_SOFTCALLERID", "T_SPY", "T_TARGET",
1209	>	"T_TLS", "T_UMODES", "T_UNDLINE", "T_UNLIMITED", "T_UNRESV", "T_UNXLINE",
1210	>	"T_WALLOP", "T_WALLOPS", "T_WEBIRC", "TBOOL", "THROTTLE_COUNT",
1211	>	"THROTTLE_TIME", "TIMEOUT", "TLS_CERTIFICATE_FILE",
1212	>	"TLS_CERTIFICATE_FINGERPRINT", "TLS_CIPHER_LIST", "TLS_CIPHER_SUITES",
1213	>	"TLS_CONNECTION_REQUIRED", "TLS_DH_PARAM_FILE",
1214	>	"TLS_MESSAGE_DIGEST_ALGORITHM", "TLS_SUPPORTED_GROUPS", "TS_MAX_DELTA",
1215	>	"TS_WARN_DELTA", "TWODOTS", "TYPE", "UNKLINE", "USE_LOGGING", "USER",
1216	>	"VHOST", "VHOST6", "WARN_NO_CONNECT_BLOCK", "WHOIS",
1217	>	"WHOWAS_HISTORY_LENGTH", "XLINE", "XLINE_EXEMPT", "QSTRING", "NUMBER",
1218	>	"';'", "'}'", "'{'", "'='", "','", "':'", "$accept", "conf", "conf_item",
1219	>	"timespec_", "timespec", "sizespec_", "sizespec", "modules_entry",
1220	>	"modules_items", "modules_item", "modules_module", "modules_path",
1221	>	"serverinfo_entry", "serverinfo_items", "serverinfo_item",
1222	>	"serverinfo_tls_certificate_file", "serverinfo_rsa_private_key_file",
1223	>	"serverinfo_tls_dh_param_file", "serverinfo_tls_cipher_list",
1224	>	"serverinfo_tls_cipher_suites",
1225	>	"serverinfo_tls_message_digest_algorithm",
1226	>	"serverinfo_tls_supported_groups", "serverinfo_name", "serverinfo_sid",
1227		"serverinfo_description", "serverinfo_network_name",
1228	<	"serverinfo_network_desc", "serverinfo_vhost", "serverinfo_vhost6",
1229	<	"serverinfo_max_clients", "serverinfo_hub", "admin_entry", "admin_items",
1230	<	"admin_item", "admin_name", "admin_email", "admin_description",
1231	<	"logging_entry", "logging_items", "logging_item", "logging_path",
1232	<	"logging_oper_log", "logging_fuserlog", "logging_ffailed_operlog",
1233	<	"logging_foperlog", "logging_foperspylog", "logging_fglinelog",
1234	<	"logging_fklinelog", "logging_ioerrlog", "logging_killlog",
1235	<	"logging_log_level", "logging_use_logging", "oper_entry", "$@2",
1236	<	"oper_name_b", "oper_items", "oper_item", "oper_name", "oper_name_t",
1237	<	"oper_user", "oper_password", "oper_encrypted",
1238	<	"oper_rsa_public_key_file", "oper_class", "oper_umodes", "$@3",
1239	<	"oper_umodes_items", "oper_umodes_item", "oper_global_kill",
1240	<	"oper_remote", "oper_remoteban", "oper_kline", "oper_xline",
1241	<	"oper_unkline", "oper_gline", "oper_nick_changes", "oper_die",
1242	<	"oper_rehash", "oper_admin", "oper_hidden_admin", "oper_hidden_oper",
1243	<	"oper_operwall", "oper_flags", "$@4", "oper_flags_items",
1244	<	"oper_flags_item", "$@5", "$@6", "oper_flags_item_atom", "class_entry",
1245	<	"$@7", "class_name_b", "class_items", "class_item", "class_name",
1246	<	"class_name_t", "class_ping_time", "class_ping_warning",
1247	<	"class_number_per_ip", "class_connectfreq", "class_max_number",
1248	<	"class_max_global", "class_max_local", "class_max_ident", "class_sendq",
1249	<	"class_cidr_bitlen_ipv4", "class_cidr_bitlen_ipv6",
1250	<	"class_number_per_cidr", "listen_entry", "$@8", "listen_flags", "$@9",
1228	>	"serverinfo_network_description", "serverinfo_default_max_clients",
1229	>	"serverinfo_max_nick_length", "serverinfo_max_topic_length",
1230	>	"serverinfo_hub", "admin_entry", "admin_items", "admin_item",
1231	>	"admin_name", "admin_email", "admin_description", "motd_entry", "$@1",
1232	>	"motd_items", "motd_item", "motd_mask", "motd_file", "pseudo_entry",
1233	>	"$@2", "pseudo_items", "pseudo_item", "pseudo_command", "pseudo_name",
1234	>	"pseudo_prepend", "pseudo_target", "logging_entry", "logging_items",
1235	>	"logging_item", "logging_use_logging", "logging_file_entry", "$@3",
1236	>	"logging_file_items", "logging_file_item", "logging_file_name",
1237	>	"logging_file_size", "logging_file_type", "$@4",
1238	>	"logging_file_type_items", "logging_file_type_item", "oper_entry", "$@5",
1239	>	"oper_items", "oper_item", "oper_name", "oper_user", "oper_password",
1240	>	"oper_whois", "oper_encrypted", "oper_tls_certificate_fingerprint",
1241	>	"oper_tls_connection_required", "oper_class", "oper_umodes", "$@6",
1242	>	"oper_umodes_items", "oper_umodes_item", "oper_flags", "$@7",
1243	>	"oper_flags_items", "oper_flags_item", "class_entry", "$@8",
1244	>	"class_items", "class_item", "class_name", "class_ping_time",
1245	>	"class_number_per_ip_local", "class_number_per_ip_global",
1246	>	"class_connectfreq", "class_max_channels", "class_max_number",
1247	>	"class_sendq", "class_recvq", "class_cidr_bitlen_ipv4",
1248	>	"class_cidr_bitlen_ipv6", "class_number_per_cidr", "class_min_idle",
1249	>	"class_max_idle", "class_flags", "$@9", "class_flags_items",
1250	>	"class_flags_item", "listen_entry", "$@10", "listen_flags", "$@11",
1251		"listen_flags_items", "listen_flags_item", "listen_items", "listen_item",
1252	<	"listen_port", "$@10", "port_items", "port_item", "listen_address",
1253	<	"listen_host", "auth_entry", "$@11", "auth_items", "auth_item",
1254	<	"auth_user", "auth_passwd", "auth_spoof_notice", "auth_class",
1255	<	"auth_encrypted", "auth_flags", "$@12", "auth_flags_items",
1256	<	"auth_flags_item", "$@13", "$@14", "auth_flags_item_atom",
1257	<	"auth_kline_exempt", "auth_need_ident", "auth_exceed_limit",
1258	<	"auth_can_flood", "auth_no_tilde", "auth_gline_exempt", "auth_spoof",
1259	<	"auth_redir_serv", "auth_redir_port", "auth_need_password", "resv_entry",
1260	<	"$@15", "resv_items", "resv_item", "resv_creason", "resv_channel",
1261	<	"resv_nick", "shared_entry", "$@16", "shared_items", "shared_item",
1262	<	"shared_name", "shared_user", "shared_type", "$@17", "shared_types",
1263	<	"shared_type_item", "cluster_entry", "$@18", "cluster_items",
1264	<	"cluster_item", "cluster_name", "cluster_type", "$@19", "cluster_types",
1265	<	"cluster_type_item", "connect_entry", "$@20", "connect_name_b",
1266	<	"connect_items", "connect_item", "connect_name", "connect_name_t",
1267	<	"connect_host", "connect_vhost", "connect_send_password",
1268	<	"connect_accept_password", "connect_port", "connect_aftype",
1269	<	"connect_fakename", "connect_flags", "$@21", "connect_flags_items",
1270	<	"connect_flags_item", "$@22", "$@23", "connect_flags_item_atom",
1271	<	"connect_rsa_public_key_file", "connect_encrypted", "connect_cryptlink",
1272	<	"connect_compressed", "connect_auto", "connect_topicburst",
1273	<	"connect_hub_mask", "connect_leaf_mask", "connect_class",
1274	<	"connect_cipher_preference", "kill_entry", "$@24", "kill_type", "$@25",
1275	<	"kill_type_items", "kill_type_item", "kill_items", "kill_item",
1276	<	"kill_user", "kill_reason", "deny_entry", "$@26", "deny_items",
1277	<	"deny_item", "deny_ip", "deny_reason", "exempt_entry", "exempt_items",
1278	<	"exempt_item", "exempt_ip", "gecos_entry", "$@27", "gecos_flags", "$@28",
1279	<	"gecos_flags_items", "gecos_flags_item", "gecos_items", "gecos_item",
1565	<	"gecos_name", "gecos_reason", "general_entry", "general_items",
1566	<	"general_item", "general_max_watch", "general_gline_min_cidr",
1567	<	"general_gline_min_cidr6", "general_burst_away",
1568	<	"general_use_whois_actually", "general_reject_hold_time",
1569	<	"general_tkline_expire_notices", "general_kill_chase_time_limit",
1570	<	"general_hide_spoof_ips", "general_ignore_bogus_ts",
1571	<	"general_disable_remote_commands", "general_failed_oper_notice",
1252	>	"listen_port", "$@12", "port_items", "port_item", "listen_address",
1253	>	"listen_host", "auth_entry", "$@13", "auth_items", "auth_item",
1254	>	"auth_user", "auth_passwd", "auth_class", "auth_encrypted", "auth_flags",
1255	>	"$@14", "auth_flags_items", "auth_flags_item", "auth_spoof",
1256	>	"auth_redir_serv", "auth_redir_port", "resv_entry", "$@15", "resv_items",
1257	>	"resv_item", "resv_mask", "resv_reason", "resv_exempt", "service_entry",
1258	>	"service_items", "service_item", "service_name", "shared_entry", "$@16",
1259	>	"shared_items", "shared_item", "shared_name", "shared_user",
1260	>	"shared_type", "$@17", "shared_types", "shared_type_item",
1261	>	"cluster_entry", "$@18", "cluster_items", "cluster_item", "cluster_name",
1262	>	"cluster_type", "$@19", "cluster_types", "cluster_type_item",
1263	>	"connect_entry", "$@20", "connect_items", "connect_item", "connect_name",
1264	>	"connect_host", "connect_timeout", "connect_bind",
1265	>	"connect_send_password", "connect_accept_password",
1266	>	"connect_tls_certificate_fingerprint", "connect_port", "connect_aftype",
1267	>	"connect_flags", "$@21", "connect_flags_items", "connect_flags_item",
1268	>	"connect_encrypted", "connect_hub_mask", "connect_leaf_mask",
1269	>	"connect_class", "connect_tls_cipher_list", "kill_entry", "$@22",
1270	>	"kill_items", "kill_item", "kill_user", "kill_reason", "deny_entry",
1271	>	"$@23", "deny_items", "deny_item", "deny_ip", "deny_reason",
1272	>	"exempt_entry", "exempt_items", "exempt_item", "exempt_ip",
1273	>	"gecos_entry", "$@24", "gecos_items", "gecos_item", "gecos_name",
1274	>	"gecos_reason", "general_entry", "general_items", "general_item",
1275	>	"general_away_count", "general_away_time", "general_max_monitor",
1276	>	"general_whowas_history_length", "general_cycle_on_host_change",
1277	>	"general_dline_min_cidr", "general_dline_min_cidr6",
1278	>	"general_kline_min_cidr", "general_kline_min_cidr6",
1279	>	"general_kill_chase_time_limit", "general_failed_oper_notice",
1280		"general_anti_nick_flood", "general_max_nick_time",
1281		"general_max_nick_changes", "general_max_accept",
1282		"general_anti_spam_exit_message_time", "general_ts_warn_delta",
1283	<	"general_ts_max_delta", "general_havent_read_conf",
1284	<	"general_kline_with_reason", "general_kline_reason",
1285	<	"general_invisible_on_connect", "general_warn_no_nline",
1286	<	"general_stats_e_disabled", "general_stats_o_oper_only",
1287	<	"general_stats_P_oper_only", "general_stats_k_oper_only",
1288	<	"general_stats_i_oper_only", "general_pace_wait",
1289	<	"general_caller_id_wait", "general_opers_bypass_callerid",
1290	<	"general_pace_wait_simple", "general_short_motd",
1291	<	"general_no_oper_flood", "general_true_no_oper_flood",
1292	<	"general_oper_pass_resv", "general_message_locale", "general_idletime",
1293	<	"general_dots_in_ident", "general_max_targets", "general_servlink_path",
1294	<	"general_default_cipher_preference", "general_compression_level",
1587	<	"general_use_egd", "general_egdpool_path", "general_ping_cookie",
1588	<	"general_disable_auth", "general_throttle_time", "general_oper_umodes",
1589	<	"$@29", "umode_oitems", "umode_oitem", "general_oper_only_umodes",
1590	<	"$@30", "umode_items", "umode_item", "general_min_nonwildcard",
1283	>	"general_ts_max_delta", "general_invisible_on_connect",
1284	>	"general_warn_no_connect_block", "general_stats_e_disabled",
1285	>	"general_stats_m_oper_only", "general_stats_o_oper_only",
1286	>	"general_stats_P_oper_only", "general_stats_u_oper_only",
1287	>	"general_stats_k_oper_only", "general_stats_i_oper_only",
1288	>	"general_pace_wait", "general_caller_id_wait",
1289	>	"general_opers_bypass_callerid", "general_pace_wait_simple",
1290	>	"general_short_motd", "general_no_oper_flood", "general_dots_in_ident",
1291	>	"general_max_targets", "general_ping_cookie", "general_disable_auth",
1292	>	"general_throttle_count", "general_throttle_time", "general_oper_umodes",
1293	>	"$@25", "umode_oitems", "umode_oitem", "general_oper_only_umodes",
1294	>	"$@26", "umode_items", "umode_item", "general_min_nonwildcard",
1295		"general_min_nonwildcard_simple", "general_default_floodcount",
1296	<	"general_client_flood", "general_dot_in_ip6_addr", "gline_entry", "$@31",
1297	<	"gline_items", "gline_item", "gline_enable", "gline_duration",
1298	<	"gline_logging", "$@32", "gline_logging_types",
1299	<	"gline_logging_type_item", "gline_user", "gline_server", "gline_action",
1300	<	"$@33", "gdeny_types", "gdeny_type_item", "channel_entry",
1301	<	"channel_items", "channel_item", "channel_disable_fake_channels",
1302	<	"channel_restrict_channels", "channel_disable_local_channels",
1303	<	"channel_use_except", "channel_use_invex", "channel_use_knock",
1304	<	"channel_knock_delay", "channel_knock_delay_channel",
1305	<	"channel_max_chans_per_user", "channel_quiet_on_ban", "channel_max_bans",
1306	<	"channel_default_split_user_count", "channel_default_split_server_count",
1307	<	"channel_no_create_on_split", "channel_no_join_on_split",
1308	<	"channel_burst_topicwho", "channel_jflood_count", "channel_jflood_time",
1309	<	"serverhide_entry", "serverhide_items", "serverhide_item",
1606	<	"serverhide_flatten_links", "serverhide_hide_servers",
1607	<	"serverhide_hidden_name", "serverhide_links_delay", "serverhide_hidden",
1608	<	"serverhide_disable_hidden", "serverhide_hide_server_ips", 0
1296	>	"general_default_floodtime", "channel_entry", "channel_items",
1297	>	"channel_item", "channel_enable_extbans",
1298	>	"channel_disable_fake_channels", "channel_invite_client_count",
1299	>	"channel_invite_client_time", "channel_invite_delay_channel",
1300	>	"channel_invite_expire_time", "channel_knock_client_count",
1301	>	"channel_knock_client_time", "channel_knock_delay_channel",
1302	>	"channel_max_channels", "channel_max_invites", "channel_max_bans",
1303	>	"channel_max_bans_large", "channel_default_join_flood_count",
1304	>	"channel_default_join_flood_time", "serverhide_entry",
1305	>	"serverhide_items", "serverhide_item", "serverhide_flatten_links",
1306	>	"serverhide_flatten_links_delay", "serverhide_flatten_links_file",
1307	>	"serverhide_disable_remote_commands", "serverhide_hide_servers",
1308	>	"serverhide_hide_services", "serverhide_hidden_name",
1309	>	"serverhide_hidden", "serverhide_hide_server_ips", YY_NULLPTR
1310		};
1311		#endif
1312
1313		# ifdef YYPRINT
1314	<	/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1315	<	token YYLEX-NUM.  */
1316	<	static const yytype_uint16 yytoknum[] =
1314	>	/* YYTOKNUM[NUM] -- (External) token number corresponding to the
1315	>	(internal) symbol number NUM (which must be that of a token).  */
1316	>	static const yytype_int16 yytoknum[] =
1317		{
1318		0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
1319		265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
#	Line 1637 | Line 1338 | static const yytype_uint16 yytoknum[] =
1338		455,   456,   457,   458,   459,   460,   461,   462,   463,   464,
1339		465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
1340		475,   476,   477,   478,   479,   480,   481,   482,   483,   484,
1341	<	485,   486,   487,   488,   489,   490,   491,   492,   493,   494,
1641	<	495,   496,   497,   498,   499,   500,   501,   502,   503,   504,
1642	<	505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
1643	<	515,   516,    59,   125,   123,    61,    44
1341	>	485,   486,    59,   125,   123,    61,    44,    58
1342		};
1343		# endif
1344
1345	<	/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
1346	<	static const yytype_uint16 yyr1[] =
1347	<	{
1348	<	0,   267,   268,   268,   269,   269,   269,   269,   269,   269,
1349	<	269,   269,   269,   269,   269,   269,   269,   269,   269,   269,
1350	<	269,   269,   269,   269,   269,   269,   270,   270,   271,   271,
1351	<	271,   271,   271,   271,   272,   272,   273,   273,   273,   273,
1352	<	274,   275,   275,   276,   276,   276,   277,   278,   279,   280,
1353	<	280,   281,   281,   281,   281,   281,   281,   281,   281,   281,
1656	<	281,   281,   281,   281,   283,   282,   284,   284,   285,   285,
1657	<	286,   287,   288,   289,   290,   291,   292,   293,   294,   295,
1658	<	296,   297,   298,   298,   299,   299,   299,   299,   300,   301,
1659	<	302,   303,   304,   304,   305,   305,   305,   305,   305,   305,
1660	<	305,   305,   305,   305,   305,   305,   305,   306,   307,   308,
1661	<	309,   310,   311,   312,   313,   314,   315,   316,   316,   316,
1662	<	316,   316,   316,   316,   317,   319,   318,   320,   320,   321,
1663	<	321,   322,   322,   322,   322,   322,   322,   322,   322,   322,
1664	<	322,   322,   322,   322,   322,   322,   322,   322,   322,   322,
1665	<	322,   322,   322,   322,   323,   324,   325,   326,   327,   328,
1666	<	329,   331,   330,   332,   332,   333,   333,   333,   333,   333,
1667	<	333,   333,   333,   333,   333,   333,   333,   333,   333,   333,
1668	<	333,   333,   333,   333,   334,   335,   336,   337,   338,   339,
1669	<	340,   341,   342,   343,   344,   345,   346,   347,   349,   348,
1670	<	350,   350,   352,   351,   353,   351,   354,   354,   354,   354,
1671	<	354,   354,   354,   354,   354,   354,   354,   354,   354,   354,
1672	<	354,   354,   356,   355,   357,   357,   358,   358,   359,   359,
1673	<	359,   359,   359,   359,   359,   359,   359,   359,   359,   359,
1674	<	359,   359,   360,   361,   362,   363,   364,   365,   366,   367,
1675	<	368,   369,   370,   371,   372,   373,   375,   374,   377,   376,
1676	<	378,   378,   379,   379,   379,   380,   380,   381,   381,   381,
1677	<	381,   381,   383,   382,   384,   384,   385,   385,   386,   387,
1678	<	389,   388,   390,   390,   391,   391,   391,   391,   391,   391,
1679	<	391,   391,   391,   391,   391,   391,   391,   391,   391,   391,
1680	<	391,   392,   393,   394,   395,   396,   398,   397,   399,   399,
1681	<	401,   400,   402,   400,   403,   403,   403,   403,   403,   403,
1682	<	403,   403,   403,   403,   404,   405,   406,   407,   408,   409,
1683	<	410,   411,   412,   413,   415,   414,   416,   416,   417,   417,
1684	<	417,   417,   418,   419,   420,   422,   421,   423,   423,   424,
1685	<	424,   424,   424,   425,   426,   428,   427,   429,   429,   430,
1686	<	430,   430,   430,   430,   430,   430,   430,   430,   430,   430,
1687	<	432,   431,   433,   433,   434,   434,   434,   435,   437,   436,
1688	<	438,   438,   439,   439,   439,   439,   439,   439,   439,   439,
1689	<	439,   439,   439,   441,   440,   442,   442,   443,   443,   444,
1690	<	444,   444,   444,   444,   444,   444,   444,   444,   444,   444,
1691	<	444,   444,   444,   444,   444,   444,   444,   444,   444,   445,
1692	<	446,   447,   448,   449,   450,   451,   452,   452,   453,   455,
1693	<	454,   456,   456,   458,   457,   459,   457,   460,   460,   460,
1694	<	460,   460,   461,   462,   463,   464,   465,   466,   467,   468,
1695	<	469,   470,   472,   471,   474,   473,   475,   475,   476,   477,
1696	<	477,   478,   478,   478,   478,   479,   480,   482,   481,   483,
1697	<	483,   484,   484,   484,   485,   486,   487,   488,   488,   489,
1698	<	489,   490,   492,   491,   494,   493,   495,   495,   496,   497,
1699	<	497,   498,   498,   498,   498,   499,   500,   501,   502,   502,
1700	<	503,   503,   503,   503,   503,   503,   503,   503,   503,   503,
1701	<	503,   503,   503,   503,   503,   503,   503,   503,   503,   503,
1702	<	503,   503,   503,   503,   503,   503,   503,   503,   503,   503,
1703	<	503,   503,   503,   503,   503,   503,   503,   503,   503,   503,
1704	<	503,   503,   503,   503,   503,   503,   503,   503,   503,   503,
1705	<	503,   503,   503,   503,   503,   503,   503,   504,   505,   506,
1706	<	507,   508,   509,   510,   511,   512,   513,   514,   515,   516,
1707	<	517,   518,   519,   520,   521,   522,   523,   524,   525,   526,
1708	<	527,   528,   529,   530,   531,   531,   532,   532,   533,   534,
1709	<	535,   536,   537,   538,   539,   540,   541,   542,   543,   544,
1710	<	545,   546,   547,   548,   549,   550,   551,   552,   554,   553,
1711	<	555,   555,   556,   556,   556,   556,   556,   556,   556,   556,
1712	<	556,   556,   556,   556,   556,   556,   556,   556,   556,   556,
1713	<	556,   558,   557,   559,   559,   560,   560,   560,   560,   560,
1714	<	560,   560,   560,   560,   560,   560,   560,   560,   560,   560,
1715	<	560,   560,   560,   560,   561,   562,   563,   564,   565,   567,
1716	<	566,   568,   568,   569,   569,   569,   569,   569,   569,   569,
1717	<	570,   571,   573,   572,   574,   574,   575,   575,   576,   577,
1718	<	579,   578,   580,   580,   581,   581,   582,   583,   583,   584,
1719	<	584,   584,   584,   584,   584,   584,   584,   584,   584,   584,
1720	<	584,   584,   584,   584,   584,   584,   584,   584,   585,   586,
1721	<	587,   588,   589,   590,   591,   592,   593,   594,   595,   596,
1722	<	597,   598,   599,   600,   601,   602,   603,   604,   604,   605,
1723	<	605,   605,   605,   605,   605,   605,   605,   606,   607,   608,
1724	<	609,   610,   611,   612
1725	<	};
1345	>	#define YYPACT_NINF (-981)
1346	>
1347	>	#define yypact_value_is_default(Yyn) \
1348	>	((Yyn) == YYPACT_NINF)
1349	>
1350	>	#define YYTABLE_NINF (-128)
1351	>
1352	>	#define yytable_value_is_error(Yyn) \
1353	>	0
1354
1355	<	/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
1356	<	static const yytype_uint8 yyr2[] =
1355	>	/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1356	>	STATE-NUM.  */
1357	>	static const yytype_int16 yypact[] =
1358		{
1359	<	0,     2,     0,     2,     1,     1,     1,     1,     1,     1,
1360	<	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1361	<	1,     1,     1,     1,     2,     2,     0,     1,     2,     3,
1362	<	3,     3,     3,     3,     0,     1,     2,     3,     3,     3,
1363	<	5,     2,     1,     1,     1,     2,     4,     4,     5,     2,
1364	<	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1365	<	1,     1,     1,     2,     0,     5,     3,     1,     1,     1,
1366	<	4,     4,     4,     4,     4,     4,     4,     4,     4,     4,
1367	<	4,     5,     2,     1,     1,     1,     1,     2,     4,     4,
1368	<	4,     5,     2,     1,     1,     1,     1,     1,     1,     1,
1369	<	1,     1,     1,     1,     1,     1,     2,     4,     4,     4,
1370	<	4,     4,     4,     4,     4,     4,     4,     4,     4,     4,
1371	<	4,     4,     4,     4,     4,     0,     7,     0,     1,     2,
1372	<	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1373	<	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1374	<	1,     1,     1,     2,     4,     1,     4,     4,     4,     4,
1375	<	4,     0,     5,     3,     1,     1,     1,     1,     1,     1,
1376	<	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1377	<	1,     1,     1,     1,     4,     4,     4,     4,     4,     4,
1378	<	4,     4,     4,     4,     4,     4,     4,     4,     0,     5,
1379	<	3,     1,     0,     3,     0,     2,     1,     1,     1,     1,
1380	<	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1381	<	1,     1,     0,     7,     0,     1,     2,     1,     1,     1,
1382	<	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1383	<	1,     2,     4,     1,     4,     4,     4,     4,     4,     4,
1384	<	4,     4,     4,     4,     4,     4,     0,     6,     0,     5,
1385	<	3,     1,     1,     1,     1,     2,     1,     1,     1,     1,
1386	<	1,     2,     0,     5,     3,     1,     1,     3,     4,     4,
1387	<	0,     6,     2,     1,     1,     1,     1,     1,     1,     1,
1388	<	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1389	<	2,     4,     4,     4,     4,     4,     0,     5,     3,     1,
1390	<	0,     3,     0,     2,     1,     1,     1,     1,     1,     1,
1391	<	1,     1,     1,     1,     4,     4,     4,     4,     4,     4,
1392	<	4,     4,     4,     4,     0,     6,     2,     1,     1,     1,
1393	<	1,     2,     4,     4,     4,     0,     6,     2,     1,     1,
1394	<	1,     1,     2,     4,     4,     0,     5,     3,     1,     1,
1395	<	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1396	<	0,     6,     2,     1,     1,     1,     2,     4,     0,     5,
1397	<	3,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1398	<	1,     1,     1,     0,     7,     0,     1,     2,     1,     1,
1399	<	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1400	<	1,     1,     1,     1,     1,     1,     1,     1,     2,     4,
1401	<	1,     4,     4,     4,     4,     4,     4,     4,     4,     0,
1402	<	5,     3,     1,     0,     3,     0,     2,     1,     1,     1,
1403	<	1,     1,     4,     4,     4,     4,     4,     4,     4,     4,
1404	<	4,     4,     0,     6,     0,     5,     3,     1,     1,     2,
1405	<	1,     1,     1,     1,     1,     4,     4,     0,     6,     2,
1406	<	1,     1,     1,     1,     4,     4,     5,     2,     1,     1,
1407	<	1,     4,     0,     6,     0,     5,     3,     1,     1,     2,
1408	<	1,     1,     1,     1,     1,     4,     4,     5,     2,     1,
1409	<	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1410	<	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1411	<	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1412	<	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1413	<	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1414	<	1,     1,     1,     1,     1,     1,     1,     4,     4,     4,
1415	<	4,     4,     4,     4,     4,     4,     4,     4,     4,     4,
1416	<	4,     4,     4,     4,     4,     4,     4,     4,     4,     4,
1417	<	4,     4,     4,     4,     4,     4,     4,     4,     4,     4,
1418	<	4,     4,     4,     4,     4,     4,     4,     4,     4,     4,
1419	<	4,     4,     4,     4,     4,     4,     4,     4,     0,     5,
1420	<	3,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1421	<	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1422	<	1,     0,     5,     3,     1,     1,     1,     1,     1,     1,
1423	<	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1424	<	1,     1,     1,     1,     4,     4,     4,     4,     4,     0,
1425	<	6,     2,     1,     1,     1,     1,     1,     1,     1,     1,
1426	<	4,     4,     0,     5,     3,     1,     1,     1,     4,     4,
1427	<	0,     5,     3,     1,     1,     1,     5,     2,     1,     1,
1428	<	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1429	<	1,     1,     1,     1,     1,     1,     1,     1,     4,     4,
1430	<	4,     4,     4,     4,     4,     4,     4,     4,     4,     4,
1431	<	4,     4,     4,     4,     4,     4,     5,     2,     1,     1,
1432	<	1,     1,     1,     1,     1,     1,     1,     4,     4,     4,
1433	<	4,     4,     4,     4
1359	>	-981,   902,  -981,  -173,  -229,  -202,  -981,  -981,  -981,  -184,
1360	>	-981,  -177,  -981,  -981,  -981,  -172,  -981,  -981,  -981,  -163,
1361	>	-161,  -981,  -123,  -981,  -106,  -981,  -981,  -981,  -981,  -981,
1362	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1363	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1364	>	-981,   281,   927,   -97,   -96,   -80,    27,   -56,   398,   -48,
1365	>	-45,   -34,    51,   -25,    -6,    -2,   558,   547,    20,    12,
1366	>	36,    15,    49,  -212,    54,    56,    61,    14,  -981,  -981,
1367	>	-981,  -981,  -981,    68,    70,    71,    72,    75,    81,    82,
1368	>	91,    92,    94,    96,    97,    98,    99,   100,     2,  -981,
1369	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1370	>	-981,  -981,  -981,  -981,  -981,   846,   633,    23,  -981,   102,
1371	>	16,  -981,  -981,    42,  -981,   104,   106,   108,   110,   112,
1372	>	117,   124,   127,   137,   138,   139,   140,   148,   149,   150,
1373	>	152,   153,   154,   156,   158,   160,   163,   174,   180,   181,
1374	>	-981,  -981,   182,   187,   191,   192,   193,   194,   196,   197,
1375	>	199,   200,   206,   207,   208,   213,   214,   215,   217,   218,
1376	>	39,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1377	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1378	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1379	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1380	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,   359,    40,   349,
1381	>	83,   219,   221,    25,  -981,  -981,  -981,    50,   335,   264,
1382	>	-981,   223,   225,   230,   231,   232,   233,   234,   236,   239,
1383	>	164,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1384	>	-981,   171,   243,   245,   250,   251,   252,   257,   261,   262,
1385	>	265,   268,   269,   270,   271,   277,   278,   285,   143,  -981,
1386	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1387	>	-981,  -981,  -981,  -981,  -981,  -981,    57,   284,   286,    13,
1388	>	-981,  -981,  -981,   363,   220,  -981,   300,    28,  -981,  -981,
1389	>	8,  -981,   307,   308,   309,   310,  -981,   224,   312,   336,
1390	>	337,   314,   312,   312,   312,   325,   312,   312,   327,   329,
1391	>	332,   333,   334,  -981,   339,   330,   340,   341,  -981,   343,
1392	>	347,   348,   350,   351,   352,   353,   355,   357,   361,   362,
1393	>	179,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1394	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,   342,   364,   365,
1395	>	366,   367,   370,   378,  -981,   385,   386,   387,   392,   397,
1396	>	405,   407,   408,   237,  -981,  -981,  -981,  -981,  -981,  -981,
1397	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1398	>	-981,   411,   412,    38,  -981,  -981,  -981,   338,   401,  -981,
1399	>	-981,   414,   415,   115,  -981,  -981,  -981,   368,   312,   399,
1400	>	312,   312,   380,   420,   312,   450,   427,   432,   434,   462,
1401	>	463,   312,   437,   439,   441,   444,   446,   312,   448,   451,
1402	>	453,   477,   452,   454,   481,   312,   312,   486,   487,   488,
1403	>	489,   493,   494,   495,   497,   501,   475,   312,   312,   312,
1404	>	504,   476,   479,  -981,   480,   474,   478,  -981,   482,   484,
1405	>	485,   490,   491,    55,  -981,  -981,  -981,  -981,  -981,  -981,
1406	>	-981,  -981,  -981,  -981,   499,   500,    80,  -981,  -981,  -981,
1407	>	483,   506,   507,  -981,   508,  -981,    26,  -981,  -981,  -981,
1408	>	-981,  -981,   492,   498,   512,  -981,   513,   511,   515,     3,
1409	>	-981,  -981,  -981,   516,   518,   519,  -981,   521,   528,  -981,
1410	>	529,   530,   531,   532,   168,  -981,  -981,  -981,  -981,  -981,
1411	>	-981,  -981,  -981,  -981,  -981,  -981,   537,   535,   536,   538,
1412	>	79,  -981,  -981,  -981,  -981,   510,   517,   312,   502,   520,
1413	>	544,   525,   543,   572,   549,  -981,  -981,   505,   554,   583,
1414	>	559,   560,   563,   567,   568,   569,   570,   573,   574,   576,
1415	>	577,   578,   582,   581,  -981,   584,   579,  -981,    62,  -981,
1416	>	-981,  -981,  -981,   598,   585,  -981,    52,   586,   580,   587,
1417	>	588,   589,   105,  -981,  -981,  -981,  -981,  -981,   590,   593,
1418	>	-981,   594,   592,  -981,   595,    41,  -981,  -981,  -981,  -981,
1419	>	596,   597,   599,  -981,   600,   228,   601,   602,   603,   604,
1420	>	605,   606,   607,   609,   614,   621,   623,   625,   626,   628,
1421	>	-981,  -981,   619,   632,   312,   631,   637,   312,   638,   312,
1422	>	591,   641,   642,   643,   312,   647,   647,   648,  -981,  -981,
1423	>	649,   -64,   651,   680,   658,   661,   660,   663,   666,   667,
1424	>	671,   674,   312,   677,   678,   679,  -981,   682,   686,   688,
1425	>	-981,   689,  -981,   694,   696,   695,  -981,   697,   698,   699,
1426	>	700,   701,   705,   706,   707,   708,   709,   711,   712,   714,
1427	>	716,   717,   718,   720,   725,   726,   730,   732,   733,   734,
1428	>	735,   736,   722,   618,   738,   741,   742,   743,   745,   746,
1429	>	747,   748,   749,   750,   751,   752,   753,   755,   756,   757,
1430	>	758,   764,  -981,  -981,   767,   794,   675,   769,   687,   770,
1431	>	771,   772,   778,  -981,   773,   774,   779,  -981,  -981,   782,
1432	>	783,   784,   786,   789,  -981,   790,   791,  -981,  -981,   795,
1433	>	796,   792,  -981,  -981,   797,   825,   798,   800,   801,   799,
1434	>	802,   831,   807,   808,   809,  -981,  -981,   810,   812,   813,
1435	>	814,  -981,   815,   818,   819,   820,   821,   822,   823,   824,
1436	>	826,  -981,   827,   828,   829,   830,   832,   834,   835,   836,
1437	>	837,   838,   839,   840,   841,   842,   843,   844,  -981,  -981,
1438	>	833,   804,   845,  -981,   847,  -981,   121,  -981,   850,   851,
1439	>	852,   854,   853,  -981,   855,  -981,  -981,   856,   857,   859,
1440	>	858,  -981,  -981,  -981,  -981,  -981,   312,   312,   312,   312,
1441	>	312,   312,   312,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1442	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,   861,
1443	>	862,   863,    -4,   864,   865,   866,   867,   868,   869,   870,
1444	>	871,   872,    22,   873,   874,  -981,   875,   876,   877,   878,
1445	>	879,   880,   881,     4,   882,   883,   884,   885,   886,   887,
1446	>	888,   889,  -981,   890,   891,  -981,  -981,   892,   893,  -981,
1447	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1448	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1449	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1450	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1451	>	-981,  -981,  -981,  -981,  -981,  -214,  -981,  -981,  -981,  -981,
1452	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1453	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -213,
1454	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1455	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,   894,
1456	>	895,   395,   896,   897,   898,   899,   900,  -981,   901,   903,
1457	>	-981,   904,   905,   266,   916,   906,  -981,  -981,  -981,  -981,
1458	>	907,   908,  -981,   909,   911,   460,   912,   913,   684,   914,
1459	>	915,   917,   918,  -981,   919,   920,   921,  -981,  -981,  -981,
1460	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1461	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1462	>	-981,  -981,  -981,   922,   503,  -981,  -981,   923,   924,   925,
1463	>	-981,   111,  -981,  -981,  -981,  -981,   926,   929,   930,   931,
1464	>	-981,  -981,   932,   552,   933,  -981,  -981,  -981,  -981,  -981,
1465	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -211,  -981,
1466	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,   647,
1467	>	647,   647,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1468	>	-981,  -981,  -981,  -981,  -981,  -199,  -981,  -981,  -981,  -981,
1469	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1470	>	722,  -981,   618,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1471	>	-981,  -981,  -981,  -981,  -160,  -981,  -981,  -981,  -981,  -981,
1472	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1473	>	-87,  -981,   935,   786,   936,  -981,  -981,  -981,  -981,  -981,
1474	>	-981,   934,  -981,   937,   938,  -981,  -981,   939,   940,  -981,
1475	>	-981,   941,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1476	>	-981,  -981,  -981,  -981,   -75,  -981,  -981,  -981,  -981,  -981,
1477	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1478	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1479	>	-61,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1480	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1481	>	-53,  -981,  -981,   942,  -137,   944,   948,  -981,  -981,  -981,
1482	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1483	>	-981,  -981,  -981,   -30,  -981,  -981,  -981,    -4,  -981,  -981,
1484	>	-981,  -981,     4,  -981,  -981,  -981,   395,  -981,   266,  -981,
1485	>	-981,  -981,  1006,   435,  1016,   910,  1024,  1025,  -981,   460,
1486	>	-981,   684,  -981,   503,   949,   950,   951,   345,  -981,  -981,
1487	>	552,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1488	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1489	>	-981,  -981,  -981,  -981,  -981,    -7,  -981,  -981,  -981,   345,
1490	>	-981
1491		};
1492
1493	<	/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
1494	<	STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
1495	<	means the default is an error.  */
1496	<	static const yytype_uint16 yydefact[] =
1497	<	{
1498	<	2,     0,     1,     0,     0,     0,   222,   393,   467,     0,
1499	<	482,     0,   659,   280,   452,   256,     0,     0,   125,   334,
1500	<	0,     0,   345,   370,     3,    23,    11,     4,     5,     6,
1501	<	8,     9,    10,    13,    14,    15,    16,    17,    18,    19,
1502	<	22,    20,    21,     7,    12,    24,    25,     0,     0,   224,
1503	<	395,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1818	<	0,   127,     0,     0,     0,     0,     0,     0,     0,     0,
1819	<	0,     0,    83,    84,    86,    85,   707,     0,     0,     0,
1820	<	0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1821	<	0,     0,     0,     0,     0,     0,   688,   706,   701,   689,
1822	<	690,   691,   692,   694,   695,   696,   697,   693,   698,   699,
1823	<	700,   702,   703,   704,   705,   243,     0,   225,   420,     0,
1824	<	396,     0,   480,     0,     0,   478,   479,     0,   556,     0,
1825	<	0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1826	<	0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1827	<	0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1828	<	0,     0,   631,     0,   608,     0,     0,     0,     0,     0,
1829	<	0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1830	<	0,     0,     0,     0,     0,     0,   499,   555,   550,   551,
1831	<	548,   552,   553,   549,   510,   500,   501,   539,   502,   503,
1832	<	504,   505,   506,   507,   508,   509,   544,   511,   512,   513,
1833	<	514,   554,   516,   521,   517,   519,   518,   533,   534,   520,
1834	<	522,   523,   524,   525,   527,   526,   515,   529,   538,   540,
1835	<	541,   530,   531,   546,   547,   543,   532,   528,   536,   537,
1836	<	535,   542,   545,     0,     0,     0,     0,     0,     0,     0,
1837	<	0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1838	<	0,    93,    94,    95,    98,   105,    99,   103,   100,   101,
1839	<	104,   102,    96,    97,     0,     0,     0,     0,    42,    43,
1840	<	44,   155,     0,   128,     0,   736,     0,     0,     0,     0,
1841	<	0,     0,     0,     0,   728,   729,   730,   734,   731,   733,
1842	<	732,   735,     0,     0,     0,     0,     0,     0,     0,     0,
1843	<	64,     0,     0,     0,     0,     0,    50,    62,    61,    58,
1844	<	51,    60,    54,    55,    56,    52,    59,    57,    53,     0,
1845	<	0,    87,     0,     0,     0,     0,    82,     0,     0,     0,
1846	<	0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1847	<	0,     0,     0,     0,     0,     0,   687,     0,     0,   473,
1848	<	0,     0,     0,   470,   471,   472,     0,     0,   477,   494,
1849	<	0,     0,   484,   493,     0,   490,   491,   492,     0,     0,
1493	>	/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
1494	>	Performed when YYTABLE does not specify something else to do.  Zero
1495	>	means the default is an error.  */
1496	>	static const yytype_int16 yydefact[] =
1497	>	{
1498	>	2,     0,     1,     0,     0,     0,   232,   394,   444,     0,
1499	>	459,     0,   298,   435,   272,     0,    98,   150,   331,     0,
1500	>	0,   372,     0,   107,     0,   348,     3,    23,    11,     4,
1501	>	24,    25,     5,     6,     8,     9,    10,    13,    14,    15,
1502	>	16,    17,    18,    19,    20,    22,    21,     7,    12,    26,
1503	>	27,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1504		0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1505	+	0,     0,     0,     0,     0,     0,     0,     0,    90,    91,
1506	+	93,    92,   628,     0,     0,     0,     0,     0,     0,     0,
1507	+	0,     0,     0,     0,     0,     0,     0,     0,     0,   612,
1508	+	627,   626,   615,   616,   617,   618,   619,   620,   621,   622,
1509	+	623,   613,   614,   624,   625,     0,     0,     0,   457,     0,
1510	+	0,   455,   456,     0,   516,     0,     0,     0,     0,     0,
1511		0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1512		0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1513	+	582,   556,     0,     0,     0,     0,     0,     0,     0,     0,
1514		0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1515	+	0,   470,   471,   472,   514,   478,   515,   509,   510,   511,
1516	+	512,   482,   473,   474,   475,   476,   477,   479,   480,   481,
1517	+	483,   484,   513,   488,   489,   490,   491,   487,   486,   492,
1518	+	499,   500,   493,   494,   495,   485,   497,   507,   508,   505,
1519	+	506,   498,   496,   503,   504,   501,   502,     0,     0,     0,
1520	+	0,     0,     0,     0,    46,    47,    48,     0,     0,     0,
1521	+	656,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1522	+	0,   646,   647,   648,   649,   650,   651,   652,   654,   653,
1523	+	655,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1524	+	0,     0,     0,     0,     0,     0,     0,     0,     0,    54,
1525	+	67,    65,    63,    68,    69,    70,    64,    55,    66,    57,
1526	+	58,    59,    60,    61,    62,    56,     0,     0,     0,     0,
1527	+	122,   123,   124,     0,     0,   346,     0,     0,   344,   345,
1528	+	0,    94,     0,     0,     0,     0,    89,     0,     0,     0,
1529		0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1530	<	0,     0,     0,     0,     0,   498,   669,   680,     0,     0,
1856	<	672,     0,     0,     0,   662,   663,   664,   665,   666,   667,
1857	<	668,     0,     0,     0,     0,     0,   306,     0,     0,     0,
1858	<	0,     0,     0,     0,     0,     0,     0,     0,     0,   283,
1859	<	284,   285,   294,   286,   299,   287,   288,   289,   290,   297,
1860	<	291,   292,   293,   295,   296,   298,   464,     0,   454,     0,
1861	<	463,     0,   460,   461,   462,     0,   258,     0,     0,     0,
1862	<	268,     0,   266,   267,   269,   270,   106,     0,     0,     0,
1530	>	0,     0,     0,   611,     0,     0,     0,     0,   266,     0,
1531		0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1532	<	92,    45,     0,     0,     0,    41,     0,     0,     0,     0,
1533	<	0,     0,   337,   338,   339,   340,     0,     0,     0,     0,
1534	<	0,     0,     0,     0,   727,    63,     0,     0,     0,     0,
1535	<	0,     0,     0,     0,     0,     0,     0,     0,     0,    49,
1536	<	0,     0,   355,     0,     0,   348,   349,   350,   351,     0,
1537	<	0,   378,     0,   373,   374,   375,     0,     0,     0,    81,
1538	<	0,     0,     0,     0,     0,    26,     0,     0,     0,     0,
1871	<	0,     0,     0,     0,     0,     0,     0,     0,     0,   686,
1532	>	0,   235,   236,   239,   241,   242,   243,   244,   245,   246,
1533	>	247,   237,   238,   240,   248,   249,   250,     0,     0,     0,
1534	>	0,     0,     0,     0,   424,     0,     0,     0,     0,     0,
1535	>	0,     0,     0,     0,   397,   398,   399,   400,   401,   402,
1536	>	403,   404,   406,   405,   408,   412,   409,   410,   411,   407,
1537	>	450,     0,     0,     0,   447,   448,   449,     0,     0,   454,
1538	>	465,     0,     0,     0,   462,   463,   464,     0,     0,     0,
1539		0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1873	–	0,     0,     0,     0,     0,   227,   228,   231,   232,   234,
1874	–	235,   236,   237,   238,   239,   240,   229,   230,   233,     0,
1875	–	0,     0,     0,     0,     0,     0,     0,     0,     0,   429,
1540		0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1877	–	398,   399,   400,   401,   402,   403,   405,   404,   406,   407,
1878	–	415,   412,   414,   413,   411,   417,   408,   409,   410,   416,
1879	–	0,     0,     0,   469,     0,   476,     0,     0,     0,     0,
1880	–	489,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1541		0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1542		0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1543	+	0,     0,     0,   469,     0,     0,     0,   315,     0,     0,
1544	+	0,     0,     0,     0,   301,   302,   303,   304,   309,   305,
1545	+	306,   307,   308,   441,     0,     0,     0,   438,   439,   440,
1546	+	0,     0,     0,   274,     0,   286,     0,   284,   285,   287,
1547	+	288,    49,     0,     0,     0,    45,     0,     0,     0,     0,
1548	+	101,   102,   103,     0,     0,     0,   199,     0,     0,   173,
1549	+	0,     0,     0,     0,     0,   153,   154,   155,   156,   157,
1550	+	160,   161,   162,   159,   158,   163,     0,     0,     0,     0,
1551	+	0,   334,   335,   336,   337,     0,     0,     0,     0,     0,
1552	+	0,     0,     0,     0,     0,   645,    71,     0,     0,     0,
1553		0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1554	+	0,     0,     0,     0,    53,     0,     0,   380,     0,   375,
1555	+	376,   377,   125,     0,     0,   121,     0,     0,     0,     0,
1556	+	0,     0,     0,   110,   111,   113,   112,   114,     0,     0,
1557	+	343,     0,     0,   358,     0,     0,   351,   352,   353,   354,
1558	+	0,     0,     0,    88,     0,    28,     0,     0,     0,     0,
1559		0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1560	<	0,     0,     0,    34,     0,     0,     0,     0,     0,     0,
1561	<	497,     0,     0,     0,     0,     0,     0,     0,   661,   300,
1560	>	610,   251,     0,     0,     0,     0,     0,     0,     0,     0,
1561	>	0,     0,     0,     0,     0,     0,     0,     0,   234,   413,
1562		0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1563	<	0,     0,     0,     0,     0,     0,     0,   282,     0,     0,
1564	<	0,     0,   459,   271,     0,     0,     0,     0,     0,   265,
1563	>	0,     0,     0,     0,     0,     0,   396,     0,     0,     0,
1564	>	446,     0,   453,     0,     0,     0,   461,     0,     0,     0,
1565		0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1891	–	0,     0,     0,     0,     0,     0,     0,     0,    91,     0,
1892	–	0,    40,     0,     0,     0,     0,     0,   198,     0,     0,
1566		0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1894	–	0,   161,     0,     0,     0,     0,   130,   131,   132,   133,
1895	–	150,   151,   137,   136,   138,   139,   145,   140,   141,   142,
1896	–	143,   144,   146,   147,   148,   134,   135,   149,   152,   341,
1897	–	0,     0,     0,     0,   336,     0,     0,     0,     0,     0,
1898	–	0,     0,   726,     0,     0,     0,     0,     0,     0,     0,
1899	–	0,     0,     0,     0,     0,    48,   352,     0,     0,     0,
1900	–	0,   347,   376,     0,     0,     0,   372,    90,    89,    88,
1901	–	723,   720,   719,   708,   710,    26,    26,    26,    26,    26,
1902	–	28,    27,   714,   715,   718,   716,   721,   722,   724,   725,
1903	–	717,   709,   711,   712,   713,   241,     0,     0,     0,     0,
1567		0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1905	–	226,   418,     0,     0,     0,     0,     0,     0,     0,     0,
1568		0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1569	<	0,     0,   397,     0,     0,   468,   481,     0,     0,     0,
1570	<	483,   569,   573,   560,   589,   602,   601,   656,   606,   567,
1571	<	658,   598,   604,   568,   558,   559,   576,   565,   597,   566,
1572	<	579,   564,   578,   577,   572,   571,   570,   599,   557,   596,
1573	<	654,   655,   593,   590,   635,   651,   652,   636,   637,   638,
1574	<	639,   646,   640,   649,   653,   642,   647,   643,   648,   641,
1575	<	645,   644,   650,     0,   634,   595,   612,   628,   629,   613,
1576	<	614,   615,   616,   623,   617,   626,   630,   619,   624,   620,
1577	<	625,   618,   622,   621,   627,     0,   611,   588,   591,   605,
1578	<	562,   600,   563,   592,   581,   586,   587,   584,   585,   582,
1579	<	583,   575,   574,    34,    34,    34,    36,    35,   657,   607,
1580	<	594,   603,   561,   580,     0,     0,     0,     0,     0,     0,
1581	<	660,     0,     0,     0,     0,   312,     0,     0,     0,     0,
1920	<	0,     0,     0,     0,     0,     0,     0,   281,     0,     0,
1921	<	0,   453,     0,     0,     0,   276,   272,   275,   257,   110,
1922	<	116,   114,   113,   115,   111,   112,   109,   117,   123,   118,
1923	<	122,   120,   121,   119,   108,   107,   124,    46,    47,   153,
1569	>	0,     0,   468,   310,     0,     0,     0,     0,     0,     0,
1570	>	0,     0,     0,   300,     0,     0,     0,   437,   289,     0,
1571	>	0,     0,     0,     0,   283,     0,     0,    44,   104,     0,
1572	>	0,     0,   100,   164,     0,     0,     0,     0,     0,     0,
1573	>	0,     0,     0,     0,     0,   152,   338,     0,     0,     0,
1574	>	0,   333,     0,     0,     0,     0,     0,     0,     0,     0,
1575	>	0,   644,     0,     0,     0,     0,     0,     0,     0,     0,
1576	>	0,     0,     0,     0,     0,     0,     0,     0,    52,   378,
1577	>	0,     0,     0,   374,     0,   120,     0,   115,     0,     0,
1578	>	0,     0,     0,   109,     0,   342,   355,     0,     0,     0,
1579	>	0,   350,    97,    96,    95,   642,    28,    28,    28,    28,
1580	>	28,    28,    28,    30,    29,   643,   630,   629,   631,   632,
1581	>	633,   634,   635,   636,   637,   640,   641,   638,   639,     0,
1582		0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1583	+	0,     0,    38,     0,     0,   233,     0,     0,     0,     0,
1584		0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1585	<	0,     0,     0,   129,     0,     0,     0,   335,   742,   737,
1586	<	741,   739,   743,   738,   740,    74,    80,    72,    76,    75,
1587	<	71,    70,    68,    69,     0,    67,    73,    79,    77,    78,
1588	<	0,     0,     0,   346,     0,     0,   371,    29,    30,    31,
1589	<	32,    33,     0,     0,     0,     0,     0,     0,     0,     0,
1590	<	0,     0,     0,     0,     0,   223,     0,     0,     0,     0,
1591	<	0,     0,     0,     0,     0,     0,   435,     0,     0,     0,
1592	<	0,     0,     0,     0,     0,     0,   394,   474,   475,   495,
1593	<	496,   488,     0,   487,   632,     0,   609,     0,    37,    38,
1594	<	39,   685,   684,     0,   683,   671,   670,   677,   676,     0,
1595	<	675,   679,   678,   327,   304,   305,   326,   310,     0,   309,
1596	<	0,   329,   325,   324,   333,   328,   302,   332,   331,   330,
1597	<	303,   301,   466,   458,     0,   457,   465,   263,   264,   262,
1598	<	0,   261,   279,   278,     0,     0,     0,     0,     0,     0,
1599	<	0,   204,     0,     0,     0,     0,     0,     0,     0,     0,
1600	<	0,     0,     0,     0,     0,     0,     0,     0,     0,   126,
1601	<	343,   344,   342,    65,     0,   353,   359,   365,   369,   368,
1602	<	367,   364,   360,   363,   366,   361,   362,     0,   358,   354,
1603	<	377,   382,   388,   392,   391,   390,   387,   383,   386,   389,
1604	<	384,   385,     0,   381,   253,   254,   247,   249,   251,   250,
1605	<	248,   242,   255,   246,   244,   245,   252,   424,   426,   427,
1606	<	446,   451,   450,   445,   444,   443,   428,   433,     0,   432,
1607	<	0,   421,   448,   449,   419,   425,   442,   423,   447,   422,
1608	<	485,     0,   633,   610,   681,     0,   673,     0,     0,   307,
1609	<	312,   318,   319,   315,   321,   317,   316,   323,   320,   322,
1610	<	314,   313,   455,     0,   259,     0,   277,   274,   273,   194,
1611	<	160,   192,   158,   202,     0,   201,     0,   190,   184,   195,
1612	<	196,   187,   154,   191,   157,   193,   185,   186,   159,   197,
1613	<	165,   181,   182,   166,   167,   168,   169,   176,   170,   179,
1614	<	183,   172,   177,   173,   178,   171,   175,   174,   180,     0,
1615	<	164,   189,   156,   188,    66,   356,     0,   379,     0,     0,
1616	<	430,   435,   439,   440,   437,   438,   441,   436,   486,   682,
1617	<	674,   311,   308,   456,   260,     0,   199,   204,   214,   212,
1618	<	221,   211,   206,   215,   219,   208,   216,   218,   213,   207,
1619	<	220,   217,   209,   210,   205,   162,     0,   357,   380,   434,
1620	<	431,   203,   200,   163
1585	>	0,     0,   395,     0,     0,   445,   458,     0,     0,   460,
1586	>	528,   532,   517,   518,   545,   521,   608,   609,   553,   522,
1587	>	523,   550,   527,   535,   526,   524,   525,   531,   519,   530,
1588	>	529,   551,   606,   607,   549,   586,   605,   592,   601,   587,
1589	>	588,   589,   596,   604,   590,   598,   602,   593,   603,   594,
1590	>	597,   591,   600,   595,   599,     0,   585,   560,   581,   565,
1591	>	566,   567,   577,   561,   562,   563,   572,   580,   564,   574,
1592	>	578,   569,   579,   570,   573,   568,   576,   571,   575,     0,
1593	>	559,   546,   544,   547,   552,   548,   537,   543,   542,   538,
1594	>	539,   540,   541,   554,   555,   534,   533,   536,   520,     0,
1595	>	0,     0,     0,     0,     0,     0,     0,   299,     0,     0,
1596	>	436,     0,     0,     0,   294,   290,   293,   273,    50,    51,
1597	>	0,     0,    99,     0,     0,     0,     0,     0,     0,     0,
1598	>	0,     0,     0,   151,     0,     0,     0,   332,   660,   657,
1599	>	658,   659,   664,   663,   665,   661,   662,    84,    81,    87,
1600	>	80,    85,    86,    79,    83,    82,    73,    72,    75,    76,
1601	>	74,    77,    78,     0,     0,   373,   126,     0,     0,     0,
1602	>	138,     0,   130,   131,   133,   132,     0,     0,     0,     0,
1603	>	108,   347,     0,     0,     0,   349,    31,    32,    33,    34,
1604	>	35,    36,    37,   261,   262,   256,   271,   270,     0,   269,
1605	>	257,   265,   258,   264,   252,   263,   255,   254,   253,    38,
1606	>	38,    38,    40,    39,   259,   260,   419,   422,   423,   433,
1607	>	430,   415,   431,   428,   429,     0,   427,   432,   414,   421,
1608	>	418,   417,   416,   420,   434,   451,   452,   466,   467,   583,
1609	>	0,   557,     0,   313,   314,   323,   319,   320,   322,   327,
1610	>	324,   325,   326,   321,     0,   318,   312,   330,   329,   328,
1611	>	311,   443,   442,   297,   296,   281,   282,   279,   280,   278,
1612	>	0,   277,     0,     0,     0,   105,   106,   172,   169,   219,
1613	>	231,   206,   215,     0,   204,   209,   225,     0,   218,   223,
1614	>	229,   208,   211,   220,   222,   226,   216,   224,   212,   230,
1615	>	214,   221,   210,   213,     0,   202,   165,   167,   177,   198,
1616	>	182,   183,   184,   194,   178,   179,   180,   189,   197,   181,
1617	>	191,   195,   186,   196,   187,   190,   185,   193,   188,   192,
1618	>	0,   176,   170,   171,   166,   168,   341,   339,   340,   379,
1619	>	384,   390,   393,   386,   392,   387,   391,   389,   385,   388,
1620	>	0,   383,   134,     0,     0,     0,     0,   129,   117,   116,
1621	>	118,   119,   356,   362,   368,   371,   364,   370,   365,   369,
1622	>	367,   363,   366,     0,   361,   357,   267,     0,    41,    42,
1623	>	43,   425,     0,   584,   558,   316,     0,   275,     0,   295,
1624	>	292,   291,     0,     0,     0,     0,     0,     0,   200,     0,
1625	>	174,     0,   381,     0,     0,     0,     0,     0,   128,   359,
1626	>	0,   268,   426,   317,   276,   205,   228,   203,   227,   217,
1627	>	207,   201,   175,   382,   135,   137,   136,   148,   147,   143,
1628	>	145,   149,   146,   142,   144,     0,   141,   360,   139,     0,
1629	>	140
1630		};
1631
1632	<	/* YYDEFGOTO[NTERM-NUM].  */
1633	<	static const yytype_int16 yydefgoto[] =
1632	>	/* YYPGOTO[NTERM-NUM].  */
1633	>	static const yytype_int16 yypgoto[] =
1634		{
1635	<	-1,     1,    24,   900,   901,  1056,  1057,    25,   277,   278,
1636	<	279,   280,    26,   315,   316,   317,   553,  1164,  1165,   318,
1637	<	319,   320,   321,   322,   323,   324,   325,   326,   327,   328,
1638	<	27,    71,    72,    73,    74,    75,    28,   260,   261,   262,
1639	<	263,   264,   265,   266,   267,   268,   269,   270,   271,   272,
1640	<	273,    29,    61,   282,   825,   826,   827,   283,   828,   829,
1641	<	830,   831,   832,   833,  1138,  1439,  1440,   834,   835,   836,
1642	<	837,   838,   839,   840,   841,   842,   843,   844,   845,   846,
1643	<	847,   848,  1124,  1404,  1405,  1465,  1406,  1484,    30,    49,
1644	<	116,   614,   615,   616,   117,   617,   618,   619,   620,   621,
1645	<	622,   623,   624,   625,   626,   627,   628,    31,    58,   500,
1646	<	774,  1270,  1271,   501,   502,   503,  1276,  1096,  1097,   504,
1647	<	505,    32,    56,   468,   469,   470,   471,   472,   473,   474,
1648	<	475,   754,  1248,  1249,  1378,  1250,  1391,   476,   477,   478,
1649	<	479,   480,   481,   482,   483,   484,   485,    33,    62,   531,
1650	<	532,   533,   534,   535,    34,    65,   564,   565,   566,   567,
1651	<	568,   878,  1317,  1318,    35,    66,   572,   573,   574,   575,
1652	<	884,  1332,  1333,    36,    50,   119,   649,   650,   651,   120,
1653	<	652,   653,   654,   655,   656,   657,   658,   659,   941,  1358,
1654	<	1359,  1449,  1360,  1457,   660,   661,   662,   663,   664,   665,
1655	<	666,   667,   668,   669,    37,    57,   490,   769,  1264,  1265,
1656	<	491,   492,   493,   494,    38,    51,   362,   363,   364,   365,
1657	<	39,   124,   125,   126,    40,    53,   373,   678,  1222,  1223,
1658	<	374,   375,   376,   377,    41,   185,   186,   187,   188,   189,
1659	<	190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
1660	<	200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
1661	<	210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
1662	<	220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
1663	<	230,   231,   232,   233,   234,   235,   236,   413,  1035,  1036,
1664	<	237,   411,  1013,  1014,   238,   239,   240,   241,   242,    42,
1997	<	55,   443,   444,   445,   446,   447,   744,  1239,  1240,   448,
1998	<	449,   450,   741,  1233,  1234,    43,    95,    96,    97,    98,
1999	<	99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
2000	<	109,   110,   111,   112,   113,   114,    44,   293,   294,   295,
2001	<	296,   297,   298,   299,   300,   301
1635	>	-981,  -981,  -981,  -293,  -306,  -980,  -635,  -981,  -981,   946,
1636	>	-981,  -981,  -981,  -981,   777,  -981,  -981,  -981,  -981,  -981,
1637	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1638	>	-981,  -981,  -981,   980,  -981,  -981,  -981,  -981,  -981,  -981,
1639	>	668,  -981,  -981,  -981,  -981,  -981,   608,  -981,  -981,  -981,
1640	>	-981,  -981,  -981,   928,  -981,  -981,  -981,  -981,   129,  -981,
1641	>	-981,  -981,  -981,  -981,  -136,  -981,  -981,  -981,   670,  -981,
1642	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1643	>	-86,  -981,  -981,  -981,   -83,  -981,  -981,  -981,   848,  -981,
1644	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1645	>	-981,  -981,  -981,  -981,  -981,  -981,   -60,  -981,  -981,  -981,
1646	>	-981,  -981,   -69,  -981,   710,  -981,  -981,  -981,    48,  -981,
1647	>	-981,  -981,  -981,  -981,   729,  -981,  -981,  -981,  -981,  -981,
1648	>	-981,  -981,   -63,  -981,  -981,  -981,  -981,  -981,  -981,   664,
1649	>	-981,  -981,  -981,  -981,  -981,   943,  -981,  -981,  -981,  -981,
1650	>	610,  -981,  -981,  -981,  -981,  -981,   -85,  -981,  -981,  -981,
1651	>	629,  -981,  -981,  -981,  -981,   -74,  -981,  -981,  -981,   849,
1652	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1653	>	-981,  -981,   -54,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1654	>	-981,   724,  -981,  -981,  -981,  -981,  -981,   811,  -981,  -981,
1655	>	-981,  -981,  1081,  -981,  -981,  -981,  -981,   803,  -981,  -981,
1656	>	-981,  -981,  1032,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1657	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1658	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1659	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1660	>	-981,  -981,  -981,  -981,  -981,    95,  -981,  -981,  -981,    93,
1661	>	-981,  -981,  -981,  -981,  -981,  -981,  1110,  -981,  -981,  -981,
1662	>	-981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,  -981,
1663	>	-981,  -981,  -981,  -981,   969,  -981,  -981,  -981,  -981,  -981,
1664	>	-981,  -981,  -981,  -981
1665		};
1666
1667	<	/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1668	<	STATE-NUM.  */
2006	<	#define YYPACT_NINF -952
2007	<	static const yytype_int16 yypact[] =
1667	>	/* YYDEFGOTO[NTERM-NUM].  */
1668	>	static const yytype_int16 yydefgoto[] =
1669		{
1670	<	-952,   888,  -952,  -233,  -260,  -258,  -952,  -952,  -952,  -255,
1671	<	-952,  -253,  -952,  -952,  -952,  -952,  -250,  -237,  -952,  -952,
1672	<	-228,  -226,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
1673	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
1674	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,   302,   766,  -136,
1675	<	-112,  -199,    17,  -193,   475,  -190,  -187,  -173,  -167,   702,
1676	<	2,   -46,  -149,   361,   520,  -140,  -134,  -130,  -121,  -102,
1677	<	-84,     4,  -952,  -952,  -952,  -952,  -952,   -82,   -77,   -62,
1678	<	-57,   -51,   -33,   -30,   -25,   -16,    -5,    -4,    20,    24,
1679	<	37,    40,    46,    49,    59,   286,  -952,  -952,  -952,  -952,
1680	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
1681	<	-952,  -952,  -952,  -952,  -952,  -952,    36,  -952,  -952,    63,
1682	<	-952,    19,  -952,    70,     7,  -952,  -952,   159,  -952,    71,
1683	<	76,    79,    84,    91,    98,   104,   105,   107,   108,   109,
1684	<	112,   113,   114,   116,   117,   118,   121,   125,   126,   130,
1685	<	132,   136,   140,   142,   144,   146,   148,   153,   155,   157,
1686	<	161,   164,  -952,   165,  -952,   169,   170,   171,   172,   173,
1687	<	181,   184,   185,   194,   196,   198,   199,   200,   201,   204,
1688	<	206,   209,   210,   212,   213,    23,  -952,  -952,  -952,  -952,
1689	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
1690	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
1691	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
1692	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
1693	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
1694	<	-952,  -952,  -952,   552,   784,    93,    88,   217,   215,   216,
1695	<	220,   224,   225,   226,   227,   231,   232,   234,   235,   239,
1696	<	133,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
1697	<	-952,  -952,  -952,  -952,   243,   241,   245,    27,  -952,  -952,
1698	<	-952,  -952,   247,  -952,    25,  -952,   248,   250,   252,   259,
1699	<	260,   261,   266,    45,  -952,  -952,  -952,  -952,  -952,  -952,
2039	<	-952,  -952,   271,   269,   270,   272,   276,   278,   279,   280,
2040	<	-952,   281,   285,   289,   290,   303,  -952,  -952,  -952,  -952,
2041	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,    56,
2042	<	62,  -952,   357,   381,   396,   296,  -952,   363,   434,   436,
2043	<	374,   375,   444,   444,   449,   450,   387,   390,   462,   444,
2044	<	397,   400,   403,   404,   405,   318,  -952,   634,   703,  -952,
2045	<	342,   343,    15,  -952,  -952,  -952,   454,   348,  -952,  -952,
2046	<	346,   353,  -952,  -952,   158,  -952,  -952,  -952,   414,   444,
2047	<	421,   444,   494,   476,   497,   433,   435,   437,   500,   483,
2048	<	440,   510,   513,   514,   451,   444,   452,   453,   516,   499,
2049	<	461,   529,   530,   444,   533,   542,   512,   543,   546,   481,
2050	<	482,   417,   484,   419,   444,   444,   486,   444,   536,   489,
2051	<	493,   495,  -150,  -141,   496,   498,   444,   444,   560,   444,
2052	<	501,   503,   509,   511,   455,  -952,  -952,  -952,   446,   456,
2053	<	-952,   457,   459,    44,  -952,  -952,  -952,  -952,  -952,  -952,
2054	<	-952,   463,   467,   468,   485,   487,  -952,   490,   506,   507,
2055	<	508,   519,   524,   526,   527,   531,   532,   544,   160,  -952,
2056	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2057	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,   548,  -952,   550,
2058	<	-952,    12,  -952,  -952,  -952,   465,  -952,   551,   553,   554,
2059	<	-952,    14,  -952,  -952,  -952,  -952,  -952,   557,   559,   561,
2060	<	564,   585,   586,   591,   592,   230,   596,   613,   577,   537,
2061	<	-952,  -952,   640,   643,   549,  -952,   574,   555,   556,   562,
2062	<	563,    32,  -952,  -952,  -952,  -952,   623,   630,   631,   665,
2063	<	632,   633,   444,   575,  -952,  -952,   681,   639,   685,   688,
2064	<	689,   690,   691,   582,   693,   565,   694,   695,   589,  -952,
2065	<	590,   593,  -952,   594,     9,  -952,  -952,  -952,  -952,   601,
2066	<	607,  -952,    33,  -952,  -952,  -952,   604,   614,   615,  -952,
2067	<	616,   619,   620,   624,   625,   189,   628,   629,   635,   636,
2068	<	637,   638,   641,   642,   644,   646,   647,   651,   654,  -952,
2069	<	656,   610,   618,   627,   655,   660,   661,   662,   663,   664,
2070	<	667,   669,   670,   671,   223,  -952,  -952,  -952,  -952,  -952,
2071	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,   657,
2072	<	672,   673,   674,   676,   679,   680,   683,   684,   686,  -952,
2073	<	687,   696,   697,   699,   700,   701,   704,   705,   706,   238,
2074	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2075	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2076	<	730,   741,   659,  -952,   668,  -952,   746,   747,   707,   711,
2077	<	-952,   712,   713,   716,   717,   719,   720,   721,   722,   723,
2078	<	724,   725,   726,   727,   729,   731,   732,   733,   734,   735,
2079	<	736,   737,   738,   739,   740,   742,   743,   744,   745,   748,
2080	<	749,   750,   751,   752,   815,   753,   871,   754,   755,   767,
2081	<	771,   774,   775,   776,   777,   778,   779,   780,   781,   782,
2082	<	786,   790,   791,   315,   793,   794,   796,   797,   798,   800,
2083	<	-952,   799,   444,   756,   801,   795,   803,   805,  -952,  -952,
2084	<	760,   812,   769,   804,   807,   809,   864,   866,   869,   870,
2085	<	918,   566,   919,   927,   886,   934,   828,  -952,   937,   829,
2086	<	938,   833,  -952,  -952,   831,   942,   943,   772,   837,  -952,
2087	<	838,   842,   846,   847,   849,   850,   857,   860,   865,   867,
2088	<	868,   872,   873,   874,   875,   879,   883,   884,  -952,   887,
2089	<	889,  -952,   890,   861,   891,   892,   893,  -952,   894,   895,
2090	<	896,   897,   898,   899,   900,   901,   902,   903,   904,   905,
2091	<	906,  -952,   907,   909,   910,   149,  -952,  -952,  -952,  -952,
2092	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2093	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2094	<	976,   977,   978,   911,  -952,   914,   915,   916,   917,   920,
2095	<	921,   922,  -952,   923,   924,   925,   926,   928,   929,   930,
2096	<	-15,   931,   932,   933,   935,  -952,  -952,   993,   936,   998,
2097	<	940,  -952,  -952,   999,   939,   941,  -952,  -952,  -952,  -952,
2098	<	-952,  -952,  -952,  -952,  -952,   444,   444,   444,   444,   444,
2099	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2100	<	-952,  -952,  -952,  -952,  -952,  -952,   813,  1022,   444,  1047,
2101	<	1048,  1056,  1063,  1043,  1066,  1067,   444,   444,   560,   944,
2102	<	-952,  -952,  1050,   -13,  1008,  1053,  1054,  1011,  1012,  1013,
2103	<	1058,   949,  1060,  1061,  1062,  1064,  1085,  1065,  1068,  1023,
2104	<	1069,   959,  -952,   963,   964,  -952,  -952,   965,   966,  1070,
2105	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2106	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2107	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2108	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2109	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2110	<	-952,  -952,  -952,  -245,  -952,  -952,  -952,  -952,  -952,  -952,
2111	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2112	<	-952,  -952,  -952,  -952,  -952,  -202,  -952,  -952,  -952,  -952,
2113	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2114	<	-952,  -952,  -952,   560,   560,   560,  -952,  -952,  -952,  -952,
2115	<	-952,  -952,  -952,  -952,     1,   967,   969,    11,   970,   971,
2116	<	-952,   972,   973,   974,   975,  1106,   979,   980,   981,   982,
2117	<	983,   984,   985,   986,   987,   988,   989,  -952,   990,  1079,
2118	<	991,  -952,     0,   992,   994,   650,   995,  -952,  -952,  -952,
2119	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2120	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2121	<	1041,  1100,  1059,  1071,   997,  1072,  1073,  1074,  1075,  1076,
2122	<	1102,  1077,  1104,  1078,  1080,  1081,  1105,  1082,  1000,  1083,
2123	<	1108,  1084,  1002,  -952,  1004,  1005,  1006,  -952,  -952,  -952,
2124	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2125	<	-952,  -952,  -952,  -952,  -174,  -952,  -952,  -952,  -952,  -952,
2126	<	1007,   534,  1016,  -952,  1024,   621,  -952,  -952,  -952,  -952,
2127	<	-952,  -952,  1025,  1026,  1027,  1028,  1029,  1030,  1031,  1032,
2128	<	1033,  1034,  1035,  1036,  1037,  -952,  1038,  1039,  1040,  1042,
2129	<	1044,  1045,  1046,  1049,  1051,  1052,  1152,  1055,  1057,  1086,
2130	<	1087,  1088,  1089,  1090,  1091,  1092,  -952,  -952,  -952,  -952,
2131	<	-952,  -952,  -148,  -952,  -952,   815,  -952,   871,  -952,  -952,
2132	<	-952,  -952,  -952,  -145,  -952,  -952,  -952,  -952,  -952,  -129,
2133	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -117,  -952,
2134	<	447,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2135	<	-952,  -952,  -952,  -952,   -35,  -952,  -952,  -952,  -952,  -952,
2136	<	-10,  -952,  -952,  -952,  1170,   772,  1093,  1094,  1095,  1096,
2137	<	1097,  1153,  1098,  1099,  1101,  1103,  1107,  1109,  1110,  1111,
2138	<	1112,  1113,  1114,  1115,  1116,   908,  1117,  1118,  1119,  -952,
2139	<	-952,  -952,  -952,  -952,   -15,  -952,  -952,  -952,  -952,  -952,
2140	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,    -8,  -952,  -952,
2141	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2142	<	-952,  -952,    35,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2143	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2144	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,    80,  -952,
2145	<	13,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2146	<	-952,  1070,  -952,  -952,  -952,     1,  -952,    11,   447,  -952,
2147	<	1106,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2148	<	-952,  -952,  -952,  1079,  -952,     0,  -952,  -952,  -952,  -952,
2149	<	-952,  -952,  -952,  -952,    89,  -952,   366,  -952,  -952,  -952,
2150	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2151	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2152	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,    95,
2153	<	-952,  -952,  -952,  -952,  -952,  -952,   534,  -952,   621,    13,
2154	<	-952,  1152,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2155	<	-952,  -952,  -952,  -952,  -952,   366,  -952,  1153,  -952,  -952,
2156	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
2157	<	-952,  -952,  -952,  -952,  -952,  -952,   908,  -952,  -952,  -952,
2158	<	-952,  -952,  -952,  -952
1670	>	-1,     1,    26,   823,   824,  1082,  1083,    27,   223,   224,
1671	>	225,   226,    28,   268,   269,   270,   271,   272,   273,   274,
1672	>	275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
1673	>	285,    29,    77,    78,    79,    80,    81,    30,    63,   499,
1674	>	500,   501,   502,    31,    70,   582,   583,   584,   585,   586,
1675	>	587,    32,   289,   290,   291,   292,   293,  1041,  1042,  1043,
1676	>	1044,  1045,  1225,  1305,  1306,    33,    64,   514,   515,   516,
1677	>	517,   518,   519,   520,   521,   522,   523,   524,   749,  1200,
1678	>	1201,   525,   746,  1174,  1175,    34,    53,   340,   341,   342,
1679	>	343,   344,   345,   346,   347,   348,   349,   350,   351,   352,
1680	>	353,   354,   355,   356,   625,  1068,  1069,    35,    61,   485,
1681	>	731,  1140,  1141,   486,   487,   488,  1144,   985,   986,   489,
1682	>	490,    36,    59,   463,   464,   465,   466,   467,   468,   469,
1683	>	716,  1124,  1125,   470,   471,   472,    37,    65,   530,   531,
1684	>	532,   533,   534,    38,   297,   298,   299,    39,    72,   595,
1685	>	596,   597,   598,   599,   808,  1243,  1244,    40,    68,   568,
1686	>	569,   570,   571,   791,  1220,  1221,    41,    54,   373,   374,
1687	>	375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
1688	>	646,  1095,  1096,   385,   386,   387,   388,   389,    42,    60,
1689	>	476,   477,   478,   479,    43,    55,   393,   394,   395,   396,
1690	>	44,   120,   121,   122,    45,    57,   403,   404,   405,   406,
1691	>	46,   170,   171,   172,   173,   174,   175,   176,   177,   178,
1692	>	179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
1693	>	189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
1694	>	199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
1695	>	209,   210,   211,   433,   949,   950,   212,   432,   925,   926,
1696	>	213,   214,   215,   216,    47,    98,    99,   100,   101,   102,
1697	>	103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
1698	>	113,   114,    48,   240,   241,   242,   243,   244,   245,   246,
1699	>	247,   248,   249,   250
1700		};
1701
1702	<	/* YYPGOTO[NTERM-NUM].  */
1703	<	static const yytype_int16 yypgoto[] =
1702	>	/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
1703	>	positive, shift that token.  If negative, reduce the rule whose
1704	>	number is the opposite.  If YYTABLE_NINF, syntax error.  */
1705	>	static const yytype_int16 yytable[] =
1706		{
1707	<	-952,  -952,  -952,  -816,  -342,  -951,  -426,  -952,  -952,   578,
1708	<	-952,  -952,  -952,  -952,   541,  -952,  -952,  -952,     5,  -952,
1709	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
1710	<	-952,  -952,  1234,  -952,  -952,  -952,  -952,  -952,  1122,  -952,
1711	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
1712	<	-952,  -952,  -952,  -952,  -952,   491,  -952,  -952,  -952,  -952,
1713	<	-952,  -952,  -952,  -952,  -952,  -952,  -176,  -952,  -952,  -952,
1714	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
1715	<	-952,  -952,  -952,  -952,  -155,  -952,  -952,  -147,  -952,  -952,
1716	<	-952,  -952,   708,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
1717	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
1718	<	-952,  -952,   -80,  -952,   819,  -952,  -952,  -952,    48,  -952,
1719	<	-952,  -952,  -952,  -952,   853,  -952,  -952,  -952,  -952,  -952,
1720	<	-952,  -952,  -952,   -56,  -952,  -952,   -53,  -952,  -952,  -952,
1721	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
1722	<	802,  -952,  -952,  -952,  -952,  -952,  -952,   762,  -952,  -952,
1723	<	-952,  -952,  -952,  -119,  -952,  -952,  -952,   757,  -952,  -952,
1724	<	-952,  -952,  -120,  -952,  -952,  -952,  -952,   682,  -952,  -952,
1725	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
1726	<	-116,  -952,  -952,  -115,  -952,  -952,  -952,  -952,  -952,  -952,
1727	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,   -63,
1728	<	-952,   841,  -952,  -952,  -952,  -952,  -952,  1021,  -952,  -952,
1729	<	-952,  -952,  1212,  -952,  -952,  -952,  -952,  -952,  -952,   -34,
1730	<	-952,   968,  -952,  -952,  -952,  -952,  1154,  -952,  -952,  -952,
1731	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
1732	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
1733	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
1734	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
1735	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,   111,
1736	<	-952,  -952,  -952,   115,  -952,  -952,  -952,  -952,  -952,  -952,
1737	<	-952,  -952,   945,  -952,  -952,  -952,  -952,  -952,   -36,  -952,
1738	<	-952,  -952,  -952,  -952,   -32,  -952,  -952,  1249,  -952,  -952,
1739	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,
1740	<	-952,  -952,  -952,  -952,  -952,  -952,  -952,  -952,  1120,  -952,
1741	<	-952,  -952,  -952,  -952,  -952,  -952
1742	<	};
1743	<
1744	<	/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
1745	<	positive, shift that token.  If negative, reduce the rule which
1746	<	number is the opposite.  If zero, do what YYDEFACT says.
1747	<	If YYTABLE_NINF, syntax error.  */
1748	<	#define YYTABLE_NINF -1
1749	<	static const yytype_uint16 yytable[] =
1750	<	{
1751	<	586,   587,   734,   274,    47,    67,    48,   593,   122,    52,
1752	<	560,    54,  1231,   486,    59,   495,   359,  1224,   122,   115,
1753	<	359,  1225,  1237,  1452,   128,  1453,   527,    60,   274,    45,
1754	<	46,   129,   130,   527,   569,   131,    63,   682,    64,   684,
1755	<	1454,    68,   132,   118,  1455,   436,   285,   528,   437,   725,
1756	<	726,   133,    69,   698,   528,   134,   135,   560,   727,   728,
1757	<	1226,   706,   136,   569,  1227,   121,   137,   138,   139,   496,
1758	<	140,   127,   717,   718,   243,   720,   141,   244,  1267,  1177,
1759	<	1178,  1179,  1180,  1181,   731,   732,   286,   735,  1303,   495,
1760	<	438,   245,  1304,   439,   486,   142,   143,   246,   123,   497,
1761	<	144,   287,  1228,  1229,  1230,   498,   360,   145,   123,   281,
1762	<	360,   146,   147,   148,  1370,   284,   149,  1374,  1371,   150,
1763	<	151,  1375,   275,   288,   329,   289,    70,   290,   291,   152,
1764	<	330,   561,   331,  1376,   247,   153,   154,  1377,   155,   156,
1765	<	157,   158,   159,   496,   332,  1379,   292,   275,   440,  1380,
1766	<	802,   529,   276,   160,   803,   570,  1162,  1163,   529,   369,
1767	<	369,   451,   161,   333,   162,   163,   441,   164,   499,   487,
1768	<	165,   166,   361,   497,   167,   804,   361,   276,   561,   498,
1769	<	452,   334,   530,   337,   570,   168,   453,   805,   338,   530,
1770	<	248,   249,   250,   251,   252,   253,   254,   255,   562,   806,
1771	<	861,   488,  1232,   339,   807,  1197,  1198,   169,   340,   170,
1772	<	454,   455,  1238,   171,   341,   456,   808,   172,   173,   174,
1773	<	175,   176,   571,   809,   600,   177,   178,  1392,   810,   457,
1774	<	811,  1393,   342,  1268,   179,   343,   458,  1269,   256,   629,
1775	<	344,   630,   499,   812,   631,   562,   601,   602,   632,   345,
1776	<	487,   571,  1394,   603,  1445,   459,  1395,  1456,  1446,   563,
1777	<	346,   347,   489,   633,   634,   635,   180,   335,   181,   636,
1778	<	367,   813,   880,   257,   182,   771,   814,   778,   672,   183,
1779	<	370,   370,   488,   460,   184,   348,   434,    76,   637,   349,
1780	<	524,   461,   638,   639,   442,   853,   885,  1447,   815,    77,
1781	<	357,  1448,   350,    67,   302,   351,   563,   747,   543,   462,
1782	<	816,   352,   817,   818,   353,   371,   371,   819,   463,   464,
1783	<	78,    79,   585,   640,   354,   641,    80,   358,    81,  1053,
1784	<	1054,  1055,   604,   605,   606,   366,   378,   607,   642,    68,
1785	<	303,   379,  1450,   489,   380,   608,  1451,   372,   372,   381,
1786	<	69,  1466,   465,   466,   258,  1467,   382,  1485,   609,   610,
1787	<	643,  1486,   285,   383,   895,   896,   897,   898,   899,   384,
1788	<	385,  1468,   386,   387,   388,   611,   612,   389,   390,   391,
1789	<	820,   392,   393,   394,    82,    83,   395,   821,   259,   304,
1790	<	396,   397,   644,    84,    85,   398,   519,   399,   822,   823,
1791	<	1065,   400,   286,   613,  1469,   401,   645,   402,   824,   403,
1792	<	467,   404,  1142,   405,    86,    87,  1470,   287,   406,   646,
1793	<	407,   679,   408,   766,    70,   305,   409,   306,   307,   410,
1794	<	412,    88,    89,  1471,   414,   415,   416,   417,   418,   288,
1795	<	1472,   289,    90,   290,   291,  1473,   419,  1474,   733,   420,
1796	<	421,    91,   788,   789,   790,   791,   792,   793,   794,   422,
1797	<	1475,   423,   292,   424,   425,   426,   427,  1381,  1382,   428,
1798	<	308,   429,   309,   310,   430,   431,   128,   432,   433,   506,
1799	<	507,   508,   647,   129,   130,   509,   929,   131,   311,   510,
1800	<	511,   512,   513,  1476,   132,   648,   514,   515,  1383,   516,
1801	<	517,   951,  1194,   133,   518,   521,   522,   134,   135,  1477,
1802	<	523,   526,   576,   536,   136,   537,  1384,   538,   137,   138,
1803	<	139,   302,   140,  1385,   539,   540,   541,  1478,   141,  1479,
1804	<	1480,   542,   312,   545,   546,   547,   577,   548,    92,    93,
1805	<	94,   549,  1386,   550,   551,   552,   554,   142,   143,   355,
1806	<	555,   578,   144,   436,   556,   557,   437,   303,   579,   145,
1807	<	313,   314,   580,   146,   147,   148,   558,   581,   149,   582,
1808	<	1387,   150,   151,   583,   584,   802,  1184,   585,  1388,   803,
1809	<	599,   152,   588,   589,  1192,  1193,   590,   153,   154,   591,
1810	<	155,   156,   157,   158,   159,   592,   594,  1481,   438,   595,
1811	<	804,   439,   596,   597,   598,   160,   304,   670,   671,   674,
1812	<	675,   676,   805,   681,   161,  1482,   162,   163,   677,   164,
1813	<	683,  1389,   165,   166,   806,  1483,   167,   685,  1306,   807,
1814	<	687,   686,   688,   691,   689,   600,   690,   168,   692,   693,
1815	<	1390,   808,   305,   694,   306,   307,   695,   696,   809,   701,
1816	<	697,   699,   700,   810,   702,   811,   440,   601,   602,   169,
1817	<	703,   170,   704,   705,   603,   171,   707,   709,   812,   172,
1818	<	173,   174,   175,   176,   441,   708,   710,   177,   178,   711,
1819	<	712,   713,   714,   715,   716,   719,   179,   308,   722,   309,
1820	<	310,   721,   723,   733,   724,   729,   813,   730,   872,  1082,
1821	<	736,   814,   737,   247,   629,   311,   630,  1307,   738,   631,
1822	<	739,   742,   780,   632,   781,  1321,   782,   740,   180,   783,
1823	<	181,   743,   745,   815,   746,   749,   182,   773,   633,   634,
1824	<	635,   183,   750,   751,   636,   816,   184,   817,   818,  1308,
1825	<	784,   785,   819,   604,   605,   606,   786,   787,   607,   312,
1826	<	752,   795,   753,   637,  1309,   755,   608,   638,   639,   248,
1827	<	249,   250,   251,   252,   253,   254,   255,    76,   796,   609,
1828	<	610,   756,   757,   758,  1310,  1311,   797,   313,   314,    77,
1829	<	1312,  1313,  1314,  1315,   759,   451,   611,   612,   640,   760,
2287	<	641,   761,   762,  1316,  1322,   799,   763,   764,   800,   798,
2288	<	78,    79,   442,   642,   452,   820,    80,   256,    81,   765,
2289	<	453,   801,   821,   768,   613,   770,   775,   849,   776,   777,
2290	<	858,   850,   855,   822,   823,   643,  1323,   851,   852,   856,
2291	<	857,   859,   860,   824,   454,   455,   863,   862,   864,   456,
2292	<	865,  1324,   257,   866,   867,   868,   869,   870,   871,   873,
2293	<	874,   875,   876,   457,  1274,   525,   559,   644,   877,   879,
2294	<	458,  1325,  1326,   882,    82,    83,   887,  1327,  1328,  1329,
2295	<	1330,   645,   883,    84,    85,   916,   888,   889,   890,   459,
2296	<	1331,   891,   892,   917,   646,   953,   893,   894,     2,     3,
2297	<	902,   903,   918,     4,    86,    87,   954,   904,   905,   906,
2298	<	907,   957,   958,   908,   909,  1095,   910,   460,   911,   912,
2299	<	5,    88,    89,   913,     6,   461,   914,     7,   915,   931,
2300	<	919,   955,    90,   258,     8,   920,   921,   922,   923,   924,
2301	<	956,    91,   925,   462,   926,   927,   928,   932,   933,   934,
2302	<	9,   935,   463,   464,   936,   937,  1182,   647,   938,   939,
2303	<	1068,   940,   942,    10,    11,  1066,    12,   259,  1069,  1071,
2304	<	648,   943,   944,    13,   945,   946,   947,  1072,  1073,   948,
2305	<	949,   950,   959,   960,   961,   962,   465,   466,   963,   964,
2306	<	14,   965,   966,   967,   968,   969,   970,   971,   972,   973,
2307	<	15,   974,    16,   975,   976,   977,   978,   979,   980,   981,
2308	<	982,   983,   984,  1074,   985,   986,   987,   988,  1076,    17,
2309	<	989,   990,   991,   992,   993,  1015,  1037,  1038,    92,    93,
2310	<	94,   994,   995,   996,   997,   998,    18,   999,  1000,  1039,
2311	<	1001,  1002,  1003,  1040,   467,  1004,  1041,  1042,  1043,  1044,
2312	<	1045,  1046,  1047,  1048,  1049,  1005,  1006,  1007,  1050,  1008,
2313	<	1009,  1010,  1051,  1052,  1011,  1058,  1059,  1012,  1060,  1061,
2314	<	1062,    19,  1063,  1077,  1064,  1078,  1067,  1070,  1079,  1080,
2315	<	20,    21,  1075,  1081,  1083,    22,    23,  1016,  1017,  1018,
2316	<	1019,  1020,  1084,  1021,  1022,  1085,  1023,  1024,  1025,  1086,
2317	<	1087,  1026,  1088,  1090,  1089,  1091,  1092,  1093,  1094,  1098,
2318	<	1099,  1027,  1028,  1029,  1100,  1030,  1031,  1032,  1101,  1102,
2319	<	1033,  1103,  1104,  1034,  1420,  1421,  1422,  1423,  1424,  1105,
2320	<	1425,  1426,  1106,  1427,  1428,  1429,  1120,  1107,  1430,  1108,
2321	<	1109,  1144,  1145,  1146,  1110,  1111,  1112,  1113,  1431,  1432,
2322	<	1433,  1114,  1434,  1435,  1436,  1115,  1116,  1437,  1170,  1117,
2323	<	1438,  1118,  1119,  1172,  1174,  1183,  1121,  1122,  1123,  1125,
2324	<	1126,  1127,  1128,  1129,  1130,  1131,  1132,  1133,  1134,  1135,
2325	<	1136,  1137,  1139,  1147,  1140,  1141,  1148,  1149,  1150,  1151,
2326	<	1185,  1186,  1152,  1153,  1154,  1155,  1156,  1157,  1158,  1187,
2327	<	1159,  1160,  1161,  1166,  1167,  1168,  1188,  1169,  1189,  1190,
2328	<	1191,  1171,  1173,  1176,  1175,  1196,  1195,  1199,  1200,  1201,
2329	<	1202,  1203,  1204,  1205,  1206,  1207,  1208,  1209,  1211,  1210,
2330	<	1212,  1216,  1214,  1213,  1215,  1217,  1218,  1219,  1220,  1235,
2331	<	1221,  1236,  1241,  1242,  1243,  1244,  1245,  1246,  1247,  1263,
2332	<	1277,  1251,  1252,  1253,  1254,  1255,  1256,  1257,  1258,  1259,
2333	<	1260,  1261,  1262,  1266,  1272,  1278,  1273,  1287,  1279,  1289,
2334	<	1293,  1275,  1281,  1297,  1299,  1295,  1300,  1301,  1302,  1305,
2335	<	1280,  1282,  1283,  1284,  1285,  1286,  1288,  1290,  1319,  1291,
2336	<	1292,  1294,  1296,  1298,  1357,  1403,  1320,  1334,  1335,  1336,
2337	<	1337,  1338,  1339,  1340,  1341,  1342,  1343,  1344,  1345,  1346,
2338	<	1347,  1348,  1349,  1396,  1350,   336,  1351,  1352,  1353,  1444,
2339	<	1493,  1354,  1492,  1355,  1356,  1464,  1143,  1361,  1491,  1362,
2340	<	779,   767,   930,  1397,  1462,  1461,   881,  1487,  1488,   886,
2341	<	1463,   952,   772,   854,  1489,  1490,   368,  1458,  1373,   435,
2342	<	1372,  1460,   680,  1459,   356,     0,     0,     0,  1363,  1364,
2343	<	1365,  1366,  1367,  1368,  1369,  1398,  1399,  1400,  1401,  1402,
2344	<	1407,  1408,     0,  1409,     0,  1410,     0,     0,     0,  1411,
2345	<	0,  1412,  1413,  1414,  1415,  1416,  1417,  1418,  1419,  1441,
2346	<	1442,  1443,   520,   673,     0,     0,     0,     0,   748,     0,
1707	>	853,   854,   606,    82,   496,    51,   610,   611,   612,   591,
1708	>	614,   615,  1093,   287,   287,    73,   295,   118,  1109,  1111,
1709	>	301,  1246,  1110,  1112,   390,  1247,   220,   480,   118,   295,
1710	>	83,    84,    52,  1251,  1079,  1080,  1081,  1252,    85,   390,
1711	>	124,   473,   591,   400,    86,   125,   126,    74,   127,   128,
1712	>	56,   496,   220,  1066,   129,    75,   454,    58,   565,    49,
1713	>	50,  1275,    62,   565,   130,   131,   132,    87,    88,    89,
1714	>	90,    66,  1255,    67,   133,   455,  1256,   134,   135,   136,
1715	>	526,   473,    91,    92,    93,   119,   137,   481,   497,    94,
1716	>	95,    96,   391,    97,   852,   482,   119,   483,   456,  1248,
1717	>	1249,  1250,   668,   138,   670,   671,   577,   391,   674,   857,
1718	>	858,    69,  1037,   592,   139,   681,   400,   140,   141,    76,
1719	>	296,   687,  1037,  1067,   527,   142,   457,   221,    71,   695,
1720	>	696,   143,   144,   296,   145,   497,   146,   115,   116,   147,
1721	>	148,   707,   708,   709,   251,  1257,   592,   401,   222,  1258,
1722	>	149,   392,   484,   221,   117,   150,   151,  1268,   152,   153,
1723	>	154,  1269,   566,   155,   528,   230,   392,   566,   474,   503,
1724	>	402,  1270,   498,   252,   222,  1271,   253,   458,   123,  1272,
1725	>	324,  -127,  -127,  1273,   459,   460,   217,   156,   504,   218,
1726	>	157,   158,   159,   160,   161,   162,   163,   325,   326,  1094,
1727	>	219,   231,  1279,   327,   461,   254,  1280,   529,   474,   227,
1728	>	578,   505,   232,   233,   234,   255,  1038,   235,   236,   498,
1729	>	401,   577,   237,   238,   239,  1308,  1038,   593,   228,  1309,
1730	>	594,   764,   229,   288,   288,   322,   741,   256,   357,   506,
1731	>	358,   257,   359,   402,   164,   165,   574,   305,   258,   398,
1732	>	328,   259,   260,   852,   286,   166,   167,   360,   494,   733,
1733	>	593,   589,   475,   594,   168,   526,   169,   579,   329,   330,
1734	>	294,   659,   452,   507,   810,   331,   567,   462,   332,   261,
1735	>	361,   567,    73,   300,   333,   580,   796,  1135,   722,   302,
1736	>	508,   303,   334,   335,   336,   792,   304,  1136,   362,   581,
1737	>	363,  1039,   475,   307,   337,   308,   309,   310,   364,   527,
1738	>	311,  1039,   760,   726,    74,   491,   312,   313,   841,  1137,
1739	>	365,   844,    75,   846,   338,   578,   314,   315,   851,   316,
1740	>	1040,   317,   318,   319,   320,   321,   503,   397,   802,   407,
1741	>	1040,   408,   366,   409,  1226,   410,   869,   411,   665,   528,
1742	>	480,   262,   412,   263,   264,   504,   265,   266,   267,   413,
1743	>	454,   339,   414,   367,   509,   816,   817,   818,   819,   820,
1744	>	821,   822,   415,   416,   417,   418,   563,   510,   505,   455,
1745	>	511,   368,   579,   419,   420,   421,    76,   422,   423,   424,
1746	>	512,   425,   529,   426,   513,   427,   369,   544,   428,   124,
1747	>	580,   754,   456,   546,   125,   126,   506,   127,   128,   429,
1748	>	481,  1115,   637,   129,   581,   430,   431,   434,   482,  1297,
1749	>	483,  1298,   435,   130,   131,   132,   436,   437,   438,   439,
1750	>	457,   440,   441,   133,   442,   443,   134,   135,   136,  1116,
1751	>	507,   444,   445,   446,   370,   137,   371,   372,   447,   448,
1752	>	449,  1138,   450,   451,   492,   604,   493,   508,   535,   605,
1753	>	536,  1139,   138,  1299,  1149,   537,   538,   539,   540,   541,
1754	>	655,   542,  1117,   139,   543,   484,   140,   141,   547,  1300,
1755	>	548,   458,  1150,  1151,   142,   549,   550,   551,   459,   460,
1756	>	143,   144,   552,   145,  1152,   146,   553,   554,   147,   148,
1757	>	555,  1118,  1119,   556,   557,   558,   559,  1120,   461,   149,
1758	>	1301,  1302,   560,   561,   150,   151,   572,   152,   153,   154,
1759	>	562,   573,   155,  1056,  1057,  1058,  1059,  1060,  1061,  1062,
1760	>	1121,   509,   576,  1153,  1154,   588,  1155,   600,   601,   602,
1761	>	607,   608,   603,   605,   510,   609,   156,   511,   251,   157,
1762	>	158,   159,   160,   161,   162,   163,   613,   512,   616,   230,
1763	>	617,   513,  1156,   618,   619,   622,   620,  1303,   661,  1286,
1764	>	1157,   621,   667,  1304,   639,   623,   624,   252,   626,  1210,
1765	>	253,   462,   627,   628,   672,   629,   630,   631,   632,  1276,
1766	>	633,  1158,   634,  1159,  1160,   231,   635,   636,  1122,   640,
1767	>	641,   642,   643,   164,   165,   644,   232,   233,   234,   254,
1768	>	1161,   235,   236,   645,   166,   167,   237,   238,   239,   255,
1769	>	647,   648,   649,   168,  1123,   169,  1162,   650,  1233,   927,
1770	>	669,  1163,   651,   662,   357,  1164,   358,  1211,   359,  1165,
1771	>	652,   256,   653,   654,  1166,   257,   657,   658,  1167,   663,
1772	>	664,   673,   258,   360,   675,   259,   260,  1168,   676,  1169,
1773	>	1170,  1212,  1171,   677,   928,   678,   679,   680,   682,  1213,
1774	>	683,   929,   684,   930,   931,   685,   361,   686,  1214,   688,
1775	>	1172,   691,   689,   261,   690,   694,  1234,   692,  1173,   693,
1776	>	697,   698,   699,   700,   362,  1178,   363,   701,   702,   703,
1777	>	1215,   704,  1216,  1217,   364,   705,   706,   711,   710,   714,
1778	>	1235,   712,   713,   715,   762,   728,   365,   717,  1236,   718,
1779	>	719,   763,   735,  1218,   766,   720,   721,  1237,   736,   768,
1780	>	1179,  1219,   765,   905,   724,   725,   772,  1180,   366,  1181,
1781	>	1182,   729,   730,   732,   737,   738,   739,   769,   743,  1238,
1782	>	740,  1239,  1240,   744,   745,   262,   747,   263,   264,   367,
1783	>	265,   266,   267,   748,   750,   751,   752,   753,   906,   756,
1784	>	757,   758,  1241,   759,   767,   907,   770,   368,   932,   933,
1785	>	1242,   771,   934,   935,   773,   936,   937,   774,   938,   775,
1786	>	939,   776,   369,   940,   777,   941,   942,   778,   779,   780,
1787	>	781,   943,   794,   782,   783,   944,   784,   785,   786,   945,
1788	>	946,   947,   787,   788,   790,   798,   789,   795,   797,   948,
1789	>	804,   847,   799,   800,   801,   805,   806,   807,   812,   813,
1790	>	809,   814,   815,   825,   826,   827,   828,   829,   830,   831,
1791	>	370,   832,   371,   372,  1183,  1184,   833,   324,  1185,  1186,
1792	>	839,  1187,  1188,   834,  1189,   835,  1190,   836,   837,  1191,
1793	>	838,  1192,  1193,   840,   325,   326,   842,  1194,   843,   845,
1794	>	327,  1195,   848,   849,   850,  1196,  1197,  1198,   852,   856,
1795	>	855,   859,   908,   909,   860,  1199,   910,   911,   861,   912,
1796	>	913,   862,   914,   864,   915,   863,   865,   916,   866,   917,
1797	>	918,   867,     2,     3,   868,   919,     4,   870,   871,   920,
1798	>	971,   872,   873,   921,   922,   923,   874,   328,   973,     5,
1799	>	875,   876,     6,   924,   877,     7,   878,   879,    82,   880,
1800	>	881,   882,   883,   884,     8,   329,   330,   885,   886,   887,
1801	>	888,   889,   331,   890,   891,   332,   892,     9,   893,   894,
1802	>	895,   333,   896,    10,    11,    83,    84,   897,   898,   334,
1803	>	335,   336,   899,    85,   900,   901,   902,   903,   904,    86,
1804	>	951,   337,    12,   952,   953,   954,    13,   955,   956,   957,
1805	>	958,   959,   960,   961,   962,   963,    14,   964,   965,   966,
1806	>	967,   338,    87,    88,    89,    90,   968,   969,   970,   972,
1807	>	974,   975,   976,   978,   979,    15,    16,    91,    92,    93,
1808	>	977,   980,   981,   982,    94,    95,    96,   984,    97,   983,
1809	>	17,   987,   988,   989,   992,   990,   991,   993,   339,   994,
1810	>	996,   997,   999,   995,   998,  1000,    18,  1001,  1002,  1034,
1811	>	1004,  1003,  1005,  1006,  1288,   564,  1007,  1008,    19,    20,
1812	>	1009,  1010,  1011,  1012,  1013,  1014,  1015,   306,  1016,  1017,
1813	>	1018,  1019,  1020,  1033,  1021,    21,  1022,  1023,  1024,  1025,
1814	>	1026,  1027,  1028,  1029,  1030,  1031,  1032,  1035,    22,  1036,
1815	>	1046,  1047,  1048,    23,  1049,  1050,  1052,  1051,    24,  1054,
1816	>	1055,    25,  1053,  1063,  1064,  1065,  1070,  1071,  1072,  1073,
1817	>	1074,  1075,  1076,  1077,  1078,  1084,  1085,  1086,  1087,  1088,
1818	>	1089,  1090,  1091,  1092,  1097,  1098,  1099,  1100,  1101,  1102,
1819	>	1103,  1104,  1105,  1106,  1107,  1108,  1113,  1114,  1126,  1127,
1820	>	1128,  1129,  1130,  1131,  1142,  1132,  1133,  1134,  1285,  1145,
1821	>	1146,  1147,  1143,  1148,  1176,  1177,  1202,  1203,  1287,  1204,
1822	>	1205,  1206,  1207,  1208,  1209,  1222,  1289,  1290,  1228,  1223,
1823	>	1224,  1229,  1230,  1231,  1232,  1245,  1259,   742,  1261,   495,
1824	>	1227,  1262,  1274,  1310,  1263,  1264,  1265,  1266,  1267,  1277,
1825	>	1278,  1294,  1295,  1296,   755,  1292,  1291,  1281,   638,  1284,
1826	>	803,  1260,   723,  1283,   761,  1307,   734,   793,  1282,  1293,
1827	>	727,   399,   453,  1253,   660,   811,   666,  1254,   323,   545,
1828	>	0,     0,     0,     0,     0,     0,     0,   575,     0,     0,
1829	>	0,     0,   656,     0,     0,     0,     0,     0,     0,     0,
1830		0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1831	<	0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2349	<	0,     0,     0,   544
1831	>	590
1832		};
1833
1834		static const yytype_int16 yycheck[] =
1835		{
1836	<	342,   343,   428,     1,   264,     1,   264,   349,     1,   264,
1837	<	1,   264,    11,     1,   264,     1,     1,   262,     1,   155,
1838	<	1,   266,    11,    10,     1,    12,     1,   264,     1,   262,
1839	<	263,     8,     9,     1,     1,    12,   264,   379,   264,   381,
1840	<	27,    37,    19,   155,    31,     1,     1,    22,     4,   199,
1841	<	200,    28,    48,   395,    22,    32,    33,     1,   199,   200,
1842	<	262,   403,    39,     1,   266,   264,    43,    44,    45,    55,
1843	<	47,   264,   414,   415,   264,   417,    53,   264,    78,   895,
1844	<	896,   897,   898,   899,   426,   427,    41,   429,   262,     1,
1845	<	46,   264,   266,    49,     1,    72,    73,   264,    91,    85,
1846	<	77,    56,  1053,  1054,  1055,    91,    91,    84,    91,   155,
1847	<	91,    88,    89,    90,   262,   264,    93,   262,   266,    96,
1848	<	97,   266,   120,    78,   264,    80,   122,    82,    83,   106,
1849	<	264,   122,   262,   262,     1,   112,   113,   266,   115,   116,
1850	<	117,   118,   119,    55,   265,   262,   101,   120,   104,   266,
1851	<	1,   126,   150,   130,     5,   122,   171,   172,   126,     1,
1852	<	1,     1,   139,   265,   141,   142,   122,   144,   154,   157,
1853	<	147,   148,   157,    85,   151,    26,   157,   150,   122,    91,
1854	<	20,   265,   157,   265,   122,   162,    26,    38,   265,   157,
1855	<	57,    58,    59,    60,    61,    62,    63,    64,   189,    50,
1856	<	542,   189,   201,   265,    55,   218,   219,   184,   265,   186,
1857	<	50,    51,   201,   190,   265,    55,    67,   194,   195,   196,
1858	<	197,   198,   189,    74,     1,   202,   203,   262,    79,    69,
1859	<	81,   266,   265,   233,   211,   265,    76,   237,   105,     1,
1860	<	265,     3,   154,    94,     6,   189,    23,    24,    10,   265,
1861	<	157,   189,   262,    30,   262,    95,   266,   244,   266,   250,
1862	<	265,   265,   250,    25,    26,    27,   243,   263,   245,    31,
1863	<	263,   122,   263,   140,   251,   263,   127,   263,   263,   256,
1864	<	122,   122,   189,   123,   261,   265,   263,     1,    50,   265,
1865	<	263,   131,    54,    55,   250,   263,   263,   262,   149,    13,
1866	<	264,   266,   265,     1,     1,   265,   250,   263,   263,   149,
1867	<	161,   265,   163,   164,   265,   157,   157,   168,   158,   159,
1868	<	34,    35,   133,    85,   265,    87,    40,   264,    42,    14,
1869	<	15,    16,   109,   110,   111,   265,   265,   114,   100,    37,
1870	<	37,   265,   262,   250,   265,   122,   266,   189,   189,   265,
1871	<	48,   262,   192,   193,   221,   266,   265,   262,   135,   136,
1872	<	122,   266,     1,   265,   175,   176,   177,   178,   179,   265,
1873	<	265,     5,   265,   265,   265,   152,   153,   265,   265,   265,
1874	<	231,   265,   265,   265,    98,    99,   265,   238,   255,    86,
1875	<	265,   265,   154,   107,   108,   265,   263,   265,   249,   250,
1876	<	742,   265,    41,   180,    38,   265,   168,   265,   259,   265,
1877	<	250,   265,   263,   265,   128,   129,    50,    56,   265,   181,
1878	<	265,   263,   265,   263,   122,   122,   265,   124,   125,   265,
1879	<	265,   145,   146,    67,   265,   265,   265,   265,   265,    78,
1880	<	74,    80,   156,    82,    83,    79,   265,    81,   133,   265,
1881	<	265,   165,   222,   223,   224,   225,   226,   227,   228,   265,
1882	<	94,   265,   101,   265,   265,   265,   265,    20,    21,   265,
1883	<	167,   265,   169,   170,   265,   265,     1,   265,   265,   262,
1884	<	265,   265,   244,     8,     9,   265,   263,    12,   185,   265,
1885	<	265,   265,   265,   127,    19,   257,   265,   265,    51,   265,
1886	<	265,   263,   928,    28,   265,   262,   265,    32,    33,   143,
1887	<	265,   264,   155,   265,    39,   265,    69,   265,    43,    44,
1888	<	45,     1,    47,    76,   265,   265,   265,   161,    53,   163,
1889	<	164,   265,   229,   262,   265,   265,   155,   265,   252,   253,
1890	<	254,   265,    95,   265,   265,   265,   265,    72,    73,   263,
1891	<	265,   155,    77,     1,   265,   265,     4,    37,   262,    84,
1892	<	257,   258,   199,    88,    89,    90,   263,   133,    93,   133,
1893	<	123,    96,    97,   199,   199,     1,   918,   133,   131,     5,
1894	<	262,   106,   133,   133,   926,   927,   199,   112,   113,   199,
1895	<	115,   116,   117,   118,   119,   133,   199,   231,    46,   199,
1896	<	26,    49,   199,   199,   199,   130,    86,   265,   265,   155,
1897	<	262,   265,    38,   199,   139,   249,   141,   142,   265,   144,
1898	<	199,   174,   147,   148,    50,   259,   151,   133,    94,    55,
1899	<	133,   155,   199,   133,   199,     1,   199,   162,   155,   199,
1900	<	193,    67,   122,   133,   124,   125,   133,   133,    74,   133,
1901	<	199,   199,   199,    79,   155,    81,   104,    23,    24,   184,
1902	<	199,   186,   133,   133,    30,   190,   133,   155,    94,   194,
1903	<	195,   196,   197,   198,   122,   133,   133,   202,   203,   133,
1904	<	199,   199,   265,   199,   265,   199,   211,   167,   199,   169,
1905	<	170,   155,   199,   133,   199,   199,   122,   199,   133,   133,
1906	<	199,   127,   199,     1,     1,   185,     3,   173,   199,     6,
1907	<	199,   265,   155,    10,   155,    94,   155,   262,   243,   155,
1908	<	245,   265,   265,   149,   265,   262,   251,   262,    25,    26,
1909	<	27,   256,   265,   265,    31,   161,   261,   163,   164,   205,
1910	<	155,   155,   168,   109,   110,   111,   155,   155,   114,   229,
1911	<	265,   155,   265,    50,   220,   265,   122,    54,    55,    57,
1912	<	58,    59,    60,    61,    62,    63,    64,     1,   155,   135,
1913	<	136,   265,   265,   265,   240,   241,   199,   257,   258,    13,
1914	<	246,   247,   248,   249,   265,     1,   152,   153,    85,   265,
1915	<	87,   265,   265,   259,   173,   155,   265,   265,   155,   262,
1916	<	34,    35,   250,   100,    20,   231,    40,   105,    42,   265,
1917	<	26,   262,   238,   265,   180,   265,   265,   262,   265,   265,
1918	<	155,   265,   199,   249,   250,   122,   205,   265,   265,   199,
1919	<	199,   199,   199,   259,    50,    51,   155,   262,   199,    55,
1920	<	155,   220,   140,   155,   155,   155,   155,   265,   155,   155,
1921	<	155,   262,   262,    69,   204,   277,   315,   154,   265,   265,
1922	<	76,   240,   241,   262,    98,    99,   262,   246,   247,   248,
1923	<	249,   168,   265,   107,   108,   265,   262,   262,   262,    95,
1924	<	259,   262,   262,   265,   181,   155,   262,   262,     0,     1,
1925	<	262,   262,   265,     5,   128,   129,   155,   262,   262,   262,
1926	<	262,   155,   155,   262,   262,   133,   262,   123,   262,   262,
1927	<	22,   145,   146,   262,    26,   131,   262,    29,   262,   262,
1928	<	265,   262,   156,   221,    36,   265,   265,   265,   265,   265,
1929	<	262,   165,   265,   149,   265,   265,   265,   265,   265,   265,
1930	<	52,   265,   158,   159,   265,   265,   133,   244,   265,   265,
1931	<	155,   265,   265,    65,    66,   199,    68,   255,   155,   199,
1932	<	257,   265,   265,    75,   265,   265,   265,   155,   199,   265,
1933	<	265,   265,   265,   262,   262,   262,   192,   193,   262,   262,
1934	<	92,   262,   262,   262,   262,   262,   262,   262,   262,   262,
1935	<	102,   262,   104,   262,   262,   262,   262,   262,   262,   262,
1936	<	262,   262,   262,   199,   262,   262,   262,   262,   199,   121,
1937	<	262,   262,   262,   262,   262,   262,   262,   262,   252,   253,
1938	<	254,   206,   207,   208,   209,   210,   138,   212,   213,   262,
1939	<	215,   216,   217,   262,   250,   220,   262,   262,   262,   262,
1940	<	262,   262,   262,   262,   262,   230,   231,   232,   262,   234,
1941	<	235,   236,   262,   262,   239,   262,   262,   242,   262,   262,
1942	<	262,   173,   262,   199,   265,   199,   265,   262,   199,   199,
1943	<	182,   183,   265,   155,   155,   187,   188,   206,   207,   208,
1944	<	209,   210,   155,   212,   213,   199,   215,   216,   217,   155,
1945	<	262,   220,   155,   155,   265,   262,   265,   155,   155,   262,
1946	<	262,   230,   231,   232,   262,   234,   235,   236,   262,   262,
1947	<	239,   262,   262,   242,   206,   207,   208,   209,   210,   262,
1948	<	212,   213,   262,   215,   216,   217,   265,   262,   220,   262,
1949	<	262,   155,   155,   155,   262,   262,   262,   262,   230,   231,
1950	<	232,   262,   234,   235,   236,   262,   262,   239,   155,   262,
1951	<	242,   262,   262,   155,   155,   133,   265,   265,   265,   265,
1952	<	265,   265,   265,   265,   265,   265,   265,   265,   265,   265,
1953	<	265,   265,   265,   262,   265,   265,   262,   262,   262,   262,
1954	<	133,   133,   262,   262,   262,   262,   262,   262,   262,   133,
1955	<	262,   262,   262,   262,   262,   262,   133,   262,   155,   133,
1956	<	133,   265,   262,   262,   265,   155,   262,   199,   155,   155,
1957	<	199,   199,   199,   155,   265,   155,   155,   155,   133,   155,
1958	<	155,   262,   199,   155,   155,   262,   262,   262,   262,   262,
2477	<	160,   262,   262,   262,   262,   262,   262,   262,   132,   160,
2478	<	199,   262,   262,   262,   262,   262,   262,   262,   262,   262,
2479	<	262,   262,   262,   262,   262,   155,   262,   155,   199,   155,
2480	<	155,   266,   265,   155,   262,   265,   262,   262,   262,   262,
2481	<	199,   199,   199,   199,   199,   199,   199,   199,   262,   199,
2482	<	199,   199,   199,   199,   132,   132,   262,   262,   262,   262,
2483	<	262,   262,   262,   262,   262,   262,   262,   262,   262,   262,
2484	<	262,   262,   262,   133,   262,    71,   262,   262,   262,  1304,
2485	<	1486,   262,  1467,   262,   262,  1395,   825,   262,  1465,   262,
2486	<	501,   468,   614,  1275,  1380,  1378,   564,  1446,  1448,   572,
2487	<	1393,   649,   491,   531,  1449,  1451,   124,  1371,  1227,   185,
2488	<	1225,  1377,   374,  1375,    95,    -1,    -1,    -1,   262,   262,
2489	<	262,   262,   262,   262,   262,   262,   262,   262,   262,   262,
2490	<	262,   262,    -1,   262,    -1,   262,    -1,    -1,    -1,   262,
2491	<	-1,   262,   262,   262,   262,   262,   262,   262,   262,   262,
2492	<	262,   262,   260,   362,    -1,    -1,    -1,    -1,   443,    -1,
2493	<	-1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1836	>	635,   636,   308,     1,     1,   234,   312,   313,   314,     1,
1837	>	316,   317,     8,     1,     1,     1,     1,     1,   232,   232,
1838	>	232,   232,   236,   236,     1,   236,     1,     1,     1,     1,
1839	>	28,    29,   234,   232,    12,    13,    14,   236,    36,     1,
1840	>	1,     1,     1,     1,    42,     6,     7,    33,     9,    10,
1841	>	234,     1,     1,    57,    15,    41,     1,   234,     1,   232,
1842	>	233,   198,   234,     1,    25,    26,    27,    65,    66,    67,
1843	>	68,   234,   232,   234,    35,    20,   236,    38,    39,    40,
1844	>	1,     1,    80,    81,    82,    69,    47,    61,    85,    87,
1845	>	88,    89,    69,    91,   231,    69,    69,    71,    43,  1079,
1846	>	1080,  1081,   408,    64,   410,   411,     1,    69,   414,   173,
1847	>	174,   234,     1,   105,    75,   421,     1,    78,    79,   105,
1848	>	105,   427,     1,   127,    45,    86,    71,   102,   234,   435,
1849	>	436,    92,    93,   105,    95,    85,    97,   234,   234,   100,
1850	>	101,   447,   448,   449,     1,   232,   105,   105,   123,   236,
1851	>	111,   128,   126,   102,   234,   116,   117,   232,   119,   120,
1852	>	121,   236,   105,   124,    85,     1,   128,   105,   128,     1,
1853	>	128,   232,   169,    30,   123,   236,    33,   122,   234,   232,
1854	>	1,   169,   169,   236,   129,   130,   234,   148,    20,   234,
1855	>	151,   152,   153,   154,   155,   156,   157,    18,    19,   195,
1856	>	234,    37,   232,    24,   149,    62,   236,   128,   128,   234,
1857	>	105,    43,    48,    49,    50,    72,   105,    53,    54,   169,
1858	>	105,     1,    58,    59,    60,   232,   105,   219,   234,   236,
1859	>	222,   537,   234,   221,   221,   233,   233,    94,     1,    71,
1860	>	3,    98,     5,   128,   205,   206,   233,   233,   105,   233,
1861	>	71,   108,   109,   231,   234,   216,   217,    20,   233,   233,
1862	>	219,   233,   222,   222,   225,     1,   227,   162,    89,    90,
1863	>	234,   233,   233,   105,   233,    96,   219,   222,    99,   136,
1864	>	43,   219,     1,   234,   105,   180,   234,    21,   233,   235,
1865	>	122,   235,   113,   114,   115,   233,   235,    31,    61,   194,
1866	>	63,   190,   222,   235,   125,   235,   235,   235,    71,    45,
1867	>	235,   190,   233,   233,    33,   232,   235,   235,   624,    53,
1868	>	83,   627,    41,   629,   145,   105,   235,   235,   634,   235,
1869	>	219,   235,   235,   235,   235,   235,     1,   235,   233,   235,
1870	>	219,   235,   105,   235,   233,   235,   652,   235,   233,    85,
1871	>	1,   208,   235,   210,   211,    20,   213,   214,   215,   235,
1872	>	1,   182,   235,   126,   196,   137,   138,   139,   140,   141,
1873	>	142,   143,   235,   235,   235,   235,   233,   209,    43,    20,
1874	>	212,   144,   162,   235,   235,   235,   105,   235,   235,   235,
1875	>	222,   235,   128,   235,   226,   235,   159,   233,   235,     1,
1876	>	180,   233,    43,   232,     6,     7,    71,     9,    10,   235,
1877	>	61,    16,   233,    15,   194,   235,   235,   235,    69,    74,
1878	>	71,    76,   235,    25,    26,    27,   235,   235,   235,   235,
1879	>	71,   235,   235,    35,   235,   235,    38,    39,    40,    44,
1880	>	105,   235,   235,   235,   207,    47,   209,   210,   235,   235,
1881	>	235,   185,   235,   235,   235,   231,   235,   122,   235,   231,
1882	>	235,   195,    64,   118,     4,   235,   235,   235,   235,   235,
1883	>	233,   235,    77,    75,   235,   126,    78,    79,   235,   134,
1884	>	235,   122,    22,    23,    86,   235,   235,   235,   129,   130,
1885	>	92,    93,   235,    95,    34,    97,   235,   235,   100,   101,
1886	>	235,   106,   107,   235,   235,   235,   235,   112,   149,   111,
1887	>	165,   166,   235,   235,   116,   117,   232,   119,   120,   121,
1888	>	235,   235,   124,   816,   817,   818,   819,   820,   821,   822,
1889	>	135,   196,   169,    73,    74,   235,    76,   230,   230,   230,
1890	>	204,   204,   232,   231,   209,   231,   148,   212,     1,   151,
1891	>	152,   153,   154,   155,   156,   157,   231,   222,   231,     1,
1892	>	231,   226,   102,   231,   231,   235,   232,   222,   230,   134,
1893	>	110,   232,   204,   228,   232,   235,   235,    30,   235,    76,
1894	>	33,   222,   235,   235,   204,   235,   235,   235,   235,  1224,
1895	>	235,   131,   235,   133,   134,    37,   235,   235,   203,   235,
1896	>	235,   235,   235,   205,   206,   235,    48,    49,    50,    62,
1897	>	150,    53,    54,   235,   216,   217,    58,    59,    60,    72,
1898	>	235,   235,   235,   225,   229,   227,   166,   235,    76,    11,
1899	>	231,   171,   235,   232,     1,   175,     3,   134,     5,   179,
1900	>	235,    94,   235,   235,   184,    98,   235,   235,   188,   235,
1901	>	235,   231,   105,    20,   204,   108,   109,   197,   231,   199,
1902	>	200,   158,   202,   231,    46,   231,   204,   204,   231,   166,
1903	>	231,    53,   231,    55,    56,   231,    43,   231,   175,   231,
1904	>	220,   204,   231,   136,   231,   204,   134,   235,   228,   235,
1905	>	204,   204,   204,   204,    61,    11,    63,   204,   204,   204,
1906	>	197,   204,   199,   200,    71,   204,   231,   231,   204,   235,
1907	>	158,   232,   232,   235,   204,   232,    83,   235,   166,   235,
1908	>	235,   204,   230,   220,   204,   235,   235,   175,   230,   204,
1909	>	46,   228,   230,    11,   235,   235,   231,    53,   105,    55,
1910	>	56,   235,   235,   235,   232,   232,   235,   204,   232,   197,
1911	>	235,   199,   200,   235,   235,   208,   235,   210,   211,   126,
1912	>	213,   214,   215,   235,   235,   235,   235,   235,    46,   232,
1913	>	235,   235,   220,   235,   230,    53,   204,   144,   160,   161,
1914	>	228,   232,   164,   165,   230,   167,   168,   204,   170,   230,
1915	>	172,   231,   159,   175,   231,   177,   178,   230,   230,   230,
1916	>	230,   183,   204,   230,   230,   187,   230,   230,   230,   191,
1917	>	192,   193,   230,   232,   235,   235,   232,   232,   232,   201,
1918	>	230,   230,   235,   235,   235,   232,   232,   235,   232,   232,
1919	>	235,   232,   232,   232,   232,   232,   232,   232,   232,   232,
1920	>	207,   232,   209,   210,   160,   161,   232,     1,   164,   165,
1921	>	231,   167,   168,   232,   170,   232,   172,   232,   232,   175,
1922	>	232,   177,   178,   231,    18,    19,   235,   183,   231,   231,
1923	>	24,   187,   231,   231,   231,   191,   192,   193,   231,   230,
1924	>	232,   230,   160,   161,   204,   201,   164,   165,   230,   167,
1925	>	168,   230,   170,   230,   172,   235,   230,   175,   231,   177,
1926	>	178,   230,     0,     1,   230,   183,     4,   230,   230,   187,
1927	>	235,   232,   230,   191,   192,   193,   230,    71,   231,    17,
1928	>	232,   232,    20,   201,   230,    23,   230,   232,     1,   232,
1929	>	232,   232,   232,   232,    32,    89,    90,   232,   232,   232,
1930	>	232,   232,    96,   232,   232,    99,   232,    45,   232,   232,
1931	>	232,   105,   232,    51,    52,    28,    29,   232,   232,   113,
1932	>	114,   115,   232,    36,   232,   232,   232,   232,   232,    42,
1933	>	232,   125,    70,   232,   232,   232,    74,   232,   232,   232,
1934	>	232,   232,   232,   232,   232,   232,    84,   232,   232,   232,
1935	>	232,   145,    65,    66,    67,    68,   232,   230,   204,   230,
1936	>	230,   230,   230,   230,   230,   103,   104,    80,    81,    82,
1937	>	232,   232,   230,   230,    87,    88,    89,   231,    91,   235,
1938	>	118,   232,   232,   232,   232,   230,   230,   230,   182,   204,
1939	>	230,   230,   230,   235,   235,   204,   134,   230,   230,   235,
1940	>	230,   232,   230,   230,   134,   268,   232,   232,   146,   147,
1941	>	232,   232,   232,   232,   232,   232,   232,    77,   232,   232,
1942	>	232,   232,   232,   230,   232,   163,   232,   232,   232,   232,
1943	>	232,   232,   232,   232,   232,   232,   232,   232,   176,   232,
1944	>	230,   230,   230,   181,   230,   232,   230,   232,   186,   230,
1945	>	232,   189,   235,   232,   232,   232,   232,   232,   232,   232,
1946	>	232,   232,   232,   232,   232,   232,   232,   232,   232,   232,
1947	>	232,   232,   232,   232,   232,   232,   232,   232,   232,   232,
1948	>	232,   232,   232,   232,   232,   232,   232,   232,   232,   232,
1949	>	232,   232,   232,   232,   218,   232,   232,   232,   132,   232,
1950	>	232,   232,   236,   232,   232,   232,   232,   232,   132,   232,
1951	>	232,   232,   232,   232,   232,   232,   132,   132,   232,   235,
1952	>	235,   232,   232,   232,   232,   232,   231,   499,   232,   223,
1953	>	1041,   237,   230,  1309,   237,   237,   237,   237,   237,   235,
1954	>	232,   232,   232,   232,   514,  1271,  1269,  1247,   340,  1258,
1955	>	582,  1143,   463,  1256,   530,  1280,   486,   568,  1252,  1273,
1956	>	476,   120,   170,  1110,   393,   595,   403,  1112,    98,   240,
1957	>	-1,    -1,    -1,    -1,    -1,    -1,    -1,   289,    -1,    -1,
1958	>	-1,    -1,   373,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1959		-1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1960	<	-1,    -1,    -1,   293
1960	>	297
1961		};
1962
1963	<	/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1964	<	symbol of state STATE-NUM.  */
1965	<	static const yytype_uint16 yystos[] =
1966	<	{
1967	<	0,   268,     0,     1,     5,    22,    26,    29,    36,    52,
1968	<	65,    66,    68,    75,    92,   102,   104,   121,   138,   173,
1969	<	182,   183,   187,   188,   269,   274,   279,   297,   303,   318,
1970	<	355,   374,   388,   414,   421,   431,   440,   471,   481,   487,
1971	<	491,   501,   566,   582,   603,   262,   263,   264,   264,   356,
1972	<	441,   482,   264,   492,   264,   567,   389,   472,   375,   264,
1973	<	264,   319,   415,   264,   264,   422,   432,     1,    37,    48,
1974	<	122,   298,   299,   300,   301,   302,     1,    13,    34,    35,
1975	<	40,    42,    98,    99,   107,   108,   128,   129,   145,   146,
1976	<	156,   165,   252,   253,   254,   583,   584,   585,   586,   587,
1977	<	588,   589,   590,   591,   592,   593,   594,   595,   596,   597,
1978	<	598,   599,   600,   601,   602,   155,   357,   361,   155,   442,
1979	<	446,   264,     1,    91,   488,   489,   490,   264,     1,     8,
1980	<	9,    12,    19,    28,    32,    33,    39,    43,    44,    45,
1981	<	47,    53,    72,    73,    77,    84,    88,    89,    90,    93,
1982	<	96,    97,   106,   112,   113,   115,   116,   117,   118,   119,
1983	<	130,   139,   141,   142,   144,   147,   148,   151,   162,   184,
1984	<	186,   190,   194,   195,   196,   197,   198,   202,   203,   211,
1985	<	243,   245,   251,   256,   261,   502,   503,   504,   505,   506,
1986	<	507,   508,   509,   510,   511,   512,   513,   514,   515,   516,
1987	<	517,   518,   519,   520,   521,   522,   523,   524,   525,   526,
1988	<	527,   528,   529,   530,   531,   532,   533,   534,   535,   536,
1989	<	537,   538,   539,   540,   541,   542,   543,   544,   545,   546,
1990	<	547,   548,   549,   550,   551,   552,   553,   557,   561,   562,
1991	<	563,   564,   565,   264,   264,   264,   264,     1,    57,    58,
1992	<	59,    60,    61,    62,    63,    64,   105,   140,   221,   255,
1993	<	304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
1994	<	314,   315,   316,   317,     1,   120,   150,   275,   276,   277,
1995	<	278,   155,   320,   324,   264,     1,    41,    56,    78,    80,
1996	<	82,    83,   101,   604,   605,   606,   607,   608,   609,   610,
1997	<	611,   612,     1,    37,    86,   122,   124,   125,   167,   169,
1998	<	170,   185,   229,   257,   258,   280,   281,   282,   286,   287,
1999	<	288,   289,   290,   291,   292,   293,   294,   295,   296,   264,
2000	<	264,   262,   265,   265,   265,   263,   299,   265,   265,   265,
2001	<	265,   265,   265,   265,   265,   265,   265,   265,   265,   265,
2002	<	265,   265,   265,   265,   265,   263,   584,   264,   264,     1,
2003	<	91,   157,   483,   484,   485,   486,   265,   263,   489,     1,
2004	<	122,   157,   189,   493,   497,   498,   499,   500,   265,   265,
2005	<	265,   265,   265,   265,   265,   265,   265,   265,   265,   265,
2006	<	265,   265,   265,   265,   265,   265,   265,   265,   265,   265,
2007	<	265,   265,   265,   265,   265,   265,   265,   265,   265,   265,
2008	<	265,   558,   265,   554,   265,   265,   265,   265,   265,   265,
2009	<	265,   265,   265,   265,   265,   265,   265,   265,   265,   265,
2010	<	265,   265,   265,   265,   263,   503,     1,     4,    46,    49,
2011	<	104,   122,   250,   568,   569,   570,   571,   572,   576,   577,
2012	<	578,     1,    20,    26,    50,    51,    55,    69,    76,    95,
2013	<	123,   131,   149,   158,   159,   192,   193,   250,   390,   391,
2014	<	392,   393,   394,   395,   396,   397,   404,   405,   406,   407,
2015	<	408,   409,   410,   411,   412,   413,     1,   157,   189,   250,
2016	<	473,   477,   478,   479,   480,     1,    55,    85,    91,   154,
2017	<	376,   380,   381,   382,   386,   387,   262,   265,   265,   265,
2018	<	265,   265,   265,   265,   265,   265,   265,   265,   265,   263,
2019	<	305,   262,   265,   265,   263,   276,   264,     1,    22,   126,
2020	<	157,   416,   417,   418,   419,   420,   265,   265,   265,   265,
2021	<	265,   265,   265,   263,   605,   262,   265,   265,   265,   265,
2022	<	265,   265,   265,   283,   265,   265,   265,   265,   263,   281,
2023	<	1,   122,   189,   250,   423,   424,   425,   426,   427,     1,
2024	<	122,   189,   433,   434,   435,   436,   155,   155,   155,   262,
2025	<	199,   133,   133,   199,   199,   133,   271,   271,   133,   133,
2026	<	199,   199,   133,   271,   199,   199,   199,   199,   199,   262,
2027	<	1,    23,    24,    30,   109,   110,   111,   114,   122,   135,
2028	<	136,   152,   153,   180,   358,   359,   360,   362,   363,   364,
2029	<	365,   366,   367,   368,   369,   370,   371,   372,   373,     1,
2030	<	3,     6,    10,    25,    26,    27,    31,    50,    54,    55,
2031	<	85,    87,   100,   122,   154,   168,   181,   244,   257,   443,
2032	<	444,   445,   447,   448,   449,   450,   451,   452,   453,   454,
2033	<	461,   462,   463,   464,   465,   466,   467,   468,   469,   470,
2034	<	265,   265,   263,   484,   155,   262,   265,   265,   494,   263,
2035	<	498,   199,   271,   199,   271,   133,   155,   133,   199,   199,
2036	<	199,   133,   155,   199,   133,   133,   133,   199,   271,   199,
2037	<	199,   133,   155,   199,   133,   133,   271,   133,   133,   155,
2038	<	133,   133,   199,   199,   265,   199,   265,   271,   271,   199,
2039	<	271,   155,   199,   199,   199,   199,   200,   199,   200,   199,
2040	<	199,   271,   271,   133,   273,   271,   199,   199,   199,   199,
2041	<	262,   579,   265,   265,   573,   265,   265,   263,   569,   262,
2042	<	265,   265,   265,   265,   398,   265,   265,   265,   265,   265,
2043	<	265,   265,   265,   265,   265,   265,   263,   391,   265,   474,
2044	<	265,   263,   478,   262,   377,   265,   265,   265,   263,   381,
2045	<	155,   155,   155,   155,   155,   155,   155,   155,   222,   223,
2046	<	224,   225,   226,   227,   228,   155,   155,   199,   262,   155,
2047	<	155,   262,     1,     5,    26,    38,    50,    55,    67,    74,
2048	<	79,    81,    94,   122,   127,   149,   161,   163,   164,   168,
2049	<	231,   238,   249,   250,   259,   321,   322,   323,   325,   326,
2050	<	327,   328,   329,   330,   334,   335,   336,   337,   338,   339,
2051	<	340,   341,   342,   343,   344,   345,   346,   347,   348,   262,
2052	<	265,   265,   265,   263,   417,   199,   199,   199,   155,   199,
2053	<	199,   271,   262,   155,   199,   155,   155,   155,   155,   155,
2054	<	265,   155,   133,   155,   155,   262,   262,   265,   428,   265,
2055	<	263,   424,   262,   265,   437,   263,   434,   262,   262,   262,
2056	<	262,   262,   262,   262,   262,   175,   176,   177,   178,   179,
2057	<	270,   271,   262,   262,   262,   262,   262,   262,   262,   262,
2058	<	262,   262,   262,   262,   262,   262,   265,   265,   265,   265,
2059	<	265,   265,   265,   265,   265,   265,   265,   265,   265,   263,
2060	<	359,   262,   265,   265,   265,   265,   265,   265,   265,   265,
2061	<	265,   455,   265,   265,   265,   265,   265,   265,   265,   265,
2062	<	265,   263,   444,   155,   155,   262,   262,   155,   155,   265,
2063	<	262,   262,   262,   262,   262,   262,   262,   262,   262,   262,
2064	<	262,   262,   262,   262,   262,   262,   262,   262,   262,   262,
2065	<	262,   262,   262,   262,   262,   262,   262,   262,   262,   262,
2066	<	262,   262,   262,   262,   206,   207,   208,   209,   210,   212,
2067	<	213,   215,   216,   217,   220,   230,   231,   232,   234,   235,
2068	<	236,   239,   242,   559,   560,   262,   206,   207,   208,   209,
2069	<	210,   212,   213,   215,   216,   217,   220,   230,   231,   232,
2070	<	234,   235,   236,   239,   242,   555,   556,   262,   262,   262,
2071	<	262,   262,   262,   262,   262,   262,   262,   262,   262,   262,
2072	<	262,   262,   262,    14,    15,    16,   272,   273,   262,   262,
2073	<	262,   262,   262,   262,   265,   271,   199,   265,   155,   155,
2074	<	262,   199,   155,   199,   199,   265,   199,   199,   199,   199,
2075	<	199,   155,   133,   155,   155,   199,   155,   262,   155,   265,
2076	<	155,   262,   265,   155,   155,   133,   384,   385,   262,   262,
2077	<	262,   262,   262,   262,   262,   262,   262,   262,   262,   262,
2078	<	262,   262,   262,   262,   262,   262,   262,   262,   262,   262,
2079	<	265,   265,   265,   265,   349,   265,   265,   265,   265,   265,
2080	<	265,   265,   265,   265,   265,   265,   265,   265,   331,   265,
2081	<	265,   265,   263,   322,   155,   155,   155,   262,   262,   262,
2082	<	262,   262,   262,   262,   262,   262,   262,   262,   262,   262,
2083	<	262,   262,   171,   172,   284,   285,   262,   262,   262,   262,
2084	<	155,   265,   155,   262,   155,   265,   262,   270,   270,   270,
2085	<	270,   270,   133,   133,   271,   133,   133,   133,   133,   155,
2086	<	133,   133,   271,   271,   273,   262,   155,   218,   219,   199,
2087	<	155,   155,   199,   199,   199,   155,   265,   155,   155,   155,
2088	<	155,   133,   155,   155,   199,   155,   262,   262,   262,   262,
2089	<	262,   160,   495,   496,   262,   266,   262,   266,   272,   272,
2090	<	272,    11,   201,   580,   581,   262,   262,    11,   201,   574,
2091	<	575,   262,   262,   262,   262,   262,   262,   132,   399,   400,
2092	<	402,   262,   262,   262,   262,   262,   262,   262,   262,   262,
2093	<	262,   262,   262,   160,   475,   476,   262,    78,   233,   237,
2094	<	378,   379,   262,   262,   204,   266,   383,   199,   155,   199,
2095	<	199,   265,   199,   199,   199,   199,   199,   155,   199,   155,
2096	<	199,   199,   199,   155,   199,   265,   199,   155,   199,   262,
2097	<	262,   262,   262,   262,   266,   262,    94,   173,   205,   220,
2098	<	240,   241,   246,   247,   248,   249,   259,   429,   430,   262,
2634	<	262,    94,   173,   205,   220,   240,   241,   246,   247,   248,
2635	<	249,   259,   438,   439,   262,   262,   262,   262,   262,   262,
2636	<	262,   262,   262,   262,   262,   262,   262,   262,   262,   262,
2637	<	262,   262,   262,   262,   262,   262,   262,   132,   456,   457,
2638	<	459,   262,   262,   262,   262,   262,   262,   262,   262,   262,
2639	<	262,   266,   560,   556,   262,   266,   262,   266,   401,   262,
2640	<	266,    20,    21,    51,    69,    76,    95,   123,   131,   174,
2641	<	193,   403,   262,   266,   262,   266,   133,   385,   262,   262,
2642	<	262,   262,   262,   132,   350,   351,   353,   262,   262,   262,
2643	<	262,   262,   262,   262,   262,   262,   262,   262,   262,   262,
2644	<	206,   207,   208,   209,   210,   212,   213,   215,   216,   217,
2645	<	220,   230,   231,   232,   234,   235,   236,   239,   242,   332,
2646	<	333,   262,   262,   262,   285,   262,   266,   262,   266,   458,
2647	<	262,   266,    10,    12,    27,    31,   244,   460,   496,   581,
2648	<	575,   403,   400,   476,   379,   352,   262,   266,     5,    38,
2649	<	50,    67,    74,    79,    81,    94,   127,   143,   161,   163,
2650	<	164,   231,   249,   259,   354,   262,   266,   430,   439,   460,
2651	<	457,   354,   351,   333
1963	>	/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1964	>	symbol of state STATE-NUM.  */
1965	>	static const yytype_int16 yystos[] =
1966	>	{
1967	>	0,   239,     0,     1,     4,    17,    20,    23,    32,    45,
1968	>	51,    52,    70,    74,    84,   103,   104,   118,   134,   146,
1969	>	147,   163,   176,   181,   186,   189,   240,   245,   250,   269,
1970	>	275,   281,   289,   303,   323,   345,   359,   374,   381,   385,
1971	>	395,   404,   426,   432,   438,   442,   448,   502,   520,   232,
1972	>	233,   234,   234,   324,   405,   433,   234,   443,   234,   360,
1973	>	427,   346,   234,   276,   304,   375,   234,   234,   396,   234,
1974	>	282,   234,   386,     1,    33,    41,   105,   270,   271,   272,
1975	>	273,   274,     1,    28,    29,    36,    42,    65,    66,    67,
1976	>	68,    80,    81,    82,    87,    88,    89,    91,   503,   504,
1977	>	505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
1978	>	515,   516,   517,   518,   519,   234,   234,   234,     1,    69,
1979	>	439,   440,   441,   234,     1,     6,     7,     9,    10,    15,
1980	>	25,    26,    27,    35,    38,    39,    40,    47,    64,    75,
1981	>	78,    79,    86,    92,    93,    95,    97,   100,   101,   111,
1982	>	116,   117,   119,   120,   121,   124,   148,   151,   152,   153,
1983	>	154,   155,   156,   157,   205,   206,   216,   217,   225,   227,
1984	>	449,   450,   451,   452,   453,   454,   455,   456,   457,   458,
1985	>	459,   460,   461,   462,   463,   464,   465,   466,   467,   468,
1986	>	469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
1987	>	479,   480,   481,   482,   483,   484,   485,   486,   487,   488,
1988	>	489,   490,   494,   498,   499,   500,   501,   234,   234,   234,
1989	>	1,   102,   123,   246,   247,   248,   249,   234,   234,   234,
1990	>	1,    37,    48,    49,    50,    53,    54,    58,    59,    60,
1991	>	521,   522,   523,   524,   525,   526,   527,   528,   529,   530,
1992	>	531,     1,    30,    33,    62,    72,    94,    98,   105,   108,
1993	>	109,   136,   208,   210,   211,   213,   214,   215,   251,   252,
1994	>	253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
1995	>	263,   264,   265,   266,   267,   268,   234,     1,   221,   290,
1996	>	291,   292,   293,   294,   234,     1,   105,   382,   383,   384,
1997	>	234,   232,   235,   235,   235,   233,   271,   235,   235,   235,
1998	>	235,   235,   235,   235,   235,   235,   235,   235,   235,   235,
1999	>	235,   235,   233,   504,     1,    18,    19,    24,    71,    89,
2000	>	90,    96,    99,   105,   113,   114,   115,   125,   145,   182,
2001	>	325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
2002	>	335,   336,   337,   338,   339,   340,   341,     1,     3,     5,
2003	>	20,    43,    61,    63,    71,    83,   105,   126,   144,   159,
2004	>	207,   209,   210,   406,   407,   408,   409,   410,   411,   412,
2005	>	413,   414,   415,   416,   417,   421,   422,   423,   424,   425,
2006	>	1,    69,   128,   434,   435,   436,   437,   235,   233,   440,
2007	>	1,   105,   128,   444,   445,   446,   447,   235,   235,   235,
2008	>	235,   235,   235,   235,   235,   235,   235,   235,   235,   235,
2009	>	235,   235,   235,   235,   235,   235,   235,   235,   235,   235,
2010	>	235,   235,   495,   491,   235,   235,   235,   235,   235,   235,
2011	>	235,   235,   235,   235,   235,   235,   235,   235,   235,   235,
2012	>	235,   235,   233,   450,     1,    20,    43,    71,   122,   129,
2013	>	130,   149,   222,   361,   362,   363,   364,   365,   366,   367,
2014	>	371,   372,   373,     1,   128,   222,   428,   429,   430,   431,
2015	>	1,    61,    69,    71,   126,   347,   351,   352,   353,   357,
2016	>	358,   232,   235,   235,   233,   247,     1,    85,   169,   277,
2017	>	278,   279,   280,     1,    20,    43,    71,   105,   122,   196,
2018	>	209,   212,   222,   226,   305,   306,   307,   308,   309,   310,
2019	>	311,   312,   313,   314,   315,   319,     1,    45,    85,   128,
2020	>	376,   377,   378,   379,   380,   235,   235,   235,   235,   235,
2021	>	235,   235,   235,   235,   233,   522,   232,   235,   235,   235,
2022	>	235,   235,   235,   235,   235,   235,   235,   235,   235,   235,
2023	>	235,   235,   235,   233,   252,     1,   105,   219,   397,   398,
2024	>	399,   400,   232,   235,   233,   291,   169,     1,   105,   162,
2025	>	180,   194,   283,   284,   285,   286,   287,   288,   235,   233,
2026	>	383,     1,   105,   219,   222,   387,   388,   389,   390,   391,
2027	>	230,   230,   230,   232,   231,   231,   242,   204,   204,   231,
2028	>	242,   242,   242,   231,   242,   242,   231,   231,   231,   231,
2029	>	232,   232,   235,   235,   235,   342,   235,   235,   235,   235,
2030	>	235,   235,   235,   235,   235,   235,   235,   233,   326,   232,
2031	>	235,   235,   235,   235,   235,   235,   418,   235,   235,   235,
2032	>	235,   235,   235,   235,   235,   233,   407,   235,   235,   233,
2033	>	435,   230,   232,   235,   235,   233,   445,   204,   242,   231,
2034	>	242,   242,   204,   231,   242,   204,   231,   231,   231,   204,
2035	>	204,   242,   231,   231,   231,   231,   231,   242,   231,   231,
2036	>	231,   204,   235,   235,   204,   242,   242,   204,   204,   204,
2037	>	204,   204,   204,   204,   204,   204,   231,   242,   242,   242,
2038	>	204,   231,   232,   232,   235,   235,   368,   235,   235,   235,
2039	>	235,   235,   233,   362,   235,   235,   233,   429,   232,   235,
2040	>	235,   348,   235,   233,   352,   230,   230,   232,   232,   235,
2041	>	235,   233,   278,   232,   235,   235,   320,   235,   235,   316,
2042	>	235,   235,   235,   235,   233,   306,   232,   235,   235,   235,
2043	>	233,   377,   204,   204,   242,   230,   204,   230,   204,   204,
2044	>	204,   232,   231,   230,   204,   230,   231,   231,   230,   230,
2045	>	230,   230,   230,   230,   230,   230,   230,   230,   232,   232,
2046	>	235,   401,   233,   398,   204,   232,   234,   232,   235,   235,
2047	>	235,   235,   233,   284,   230,   232,   232,   235,   392,   235,
2048	>	233,   388,   232,   232,   232,   232,   137,   138,   139,   140,
2049	>	141,   142,   143,   241,   242,   232,   232,   232,   232,   232,
2050	>	232,   232,   232,   232,   232,   232,   232,   232,   232,   231,
2051	>	231,   242,   235,   231,   242,   231,   242,   230,   231,   231,
2052	>	231,   242,   231,   244,   244,   232,   230,   173,   174,   230,
2053	>	204,   230,   230,   235,   230,   230,   231,   230,   230,   242,
2054	>	230,   230,   232,   230,   230,   232,   232,   230,   230,   232,
2055	>	232,   232,   232,   232,   232,   232,   232,   232,   232,   232,
2056	>	232,   232,   232,   232,   232,   232,   232,   232,   232,   232,
2057	>	232,   232,   232,   232,   232,    11,    46,    53,   160,   161,
2058	>	164,   165,   167,   168,   170,   172,   175,   177,   178,   183,
2059	>	187,   191,   192,   193,   201,   496,   497,    11,    46,    53,
2060	>	55,    56,   160,   161,   164,   165,   167,   168,   170,   172,
2061	>	175,   177,   178,   183,   187,   191,   192,   193,   201,   492,
2062	>	493,   232,   232,   232,   232,   232,   232,   232,   232,   232,
2063	>	232,   232,   232,   232,   232,   232,   232,   232,   232,   230,
2064	>	204,   235,   230,   231,   230,   230,   230,   232,   230,   230,
2065	>	232,   230,   230,   235,   231,   355,   356,   232,   232,   232,
2066	>	230,   230,   232,   230,   204,   235,   230,   230,   235,   230,
2067	>	204,   230,   230,   232,   230,   230,   230,   232,   232,   232,
2068	>	232,   232,   232,   232,   232,   232,   232,   232,   232,   232,
2069	>	232,   232,   232,   232,   232,   232,   232,   232,   232,   232,
2070	>	232,   232,   232,   230,   235,   232,   232,     1,   105,   190,
2071	>	219,   295,   296,   297,   298,   299,   230,   230,   230,   230,
2072	>	232,   232,   230,   235,   230,   232,   241,   241,   241,   241,
2073	>	241,   241,   241,   232,   232,   232,    57,   127,   343,   344,
2074	>	232,   232,   232,   232,   232,   232,   232,   232,   232,    12,
2075	>	13,    14,   243,   244,   232,   232,   232,   232,   232,   232,
2076	>	232,   232,   232,     8,   195,   419,   420,   232,   232,   232,
2077	>	232,   232,   232,   232,   232,   232,   232,   232,   232,   232,
2078	>	236,   232,   236,   232,   232,    16,    44,    77,   106,   107,
2079	>	112,   135,   203,   229,   369,   370,   232,   232,   232,   232,
2080	>	232,   232,   232,   232,   232,    21,    31,    53,   185,   195,
2081	>	349,   350,   218,   236,   354,   232,   232,   232,   232,     4,
2082	>	22,    23,    34,    73,    74,    76,   102,   110,   131,   133,
2083	>	134,   150,   166,   171,   175,   179,   184,   188,   197,   199,
2084	>	200,   202,   220,   228,   321,   322,   232,   232,    11,    46,
2085	>	53,    55,    56,   160,   161,   164,   165,   167,   168,   170,
2086	>	172,   175,   177,   178,   183,   187,   191,   192,   193,   201,
2087	>	317,   318,   232,   232,   232,   232,   232,   232,   232,   232,
2088	>	76,   134,   158,   166,   175,   197,   199,   200,   220,   228,
2089	>	402,   403,   232,   235,   235,   300,   233,   296,   232,   232,
2090	>	232,   232,   232,    76,   134,   158,   166,   175,   197,   199,
2091	>	200,   220,   228,   393,   394,   232,   232,   236,   243,   243,
2092	>	243,   232,   236,   497,   493,   232,   236,   232,   236,   231,
2093	>	356,   232,   237,   237,   237,   237,   237,   237,   232,   236,
2094	>	232,   236,   232,   236,   230,   198,   244,   235,   232,   232,
2095	>	236,   344,   420,   370,   350,   132,   134,   132,   134,   132,
2096	>	132,   322,   318,   403,   232,   232,   232,    74,    76,   118,
2097	>	134,   165,   166,   222,   228,   301,   302,   394,   232,   236,
2098	>	302
2099		};
2100
2101	<	#define yyerrok         (yyerrstatus = 0)
2102	<	#define yyclearin       (yychar = YYEMPTY)
2103	<	#define YYEMPTY         (-2)
2104	<	#define YYEOF           0
2101	>	/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
2102	>	static const yytype_int16 yyr1[] =
2103	>	{
2104	>	0,   238,   239,   239,   240,   240,   240,   240,   240,   240,
2105	>	240,   240,   240,   240,   240,   240,   240,   240,   240,   240,
2106	>	240,   240,   240,   240,   240,   240,   240,   240,   241,   241,
2107	>	242,   242,   242,   242,   242,   242,   242,   242,   243,   243,
2108	>	244,   244,   244,   244,   245,   246,   246,   247,   247,   247,
2109	>	248,   249,   250,   251,   251,   252,   252,   252,   252,   252,
2110	>	252,   252,   252,   252,   252,   252,   252,   252,   252,   252,
2111	>	252,   252,   253,   254,   255,   256,   257,   258,   259,   260,
2112	>	261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
2113	>	270,   271,   271,   271,   271,   272,   273,   274,   276,   275,
2114	>	277,   277,   278,   278,   278,   279,   280,   282,   281,   283,
2115	>	283,   284,   284,   284,   284,   284,   285,   286,   287,   288,
2116	>	289,   290,   290,   291,   291,   291,   292,   294,   293,   295,
2117	>	295,   296,   296,   296,   296,   297,   298,   298,   300,   299,
2118	>	301,   301,   302,   302,   302,   302,   302,   302,   302,   302,
2119	>	304,   303,   305,   305,   306,   306,   306,   306,   306,   306,
2120	>	306,   306,   306,   306,   306,   307,   308,   309,   310,   311,
2121	>	312,   313,   314,   316,   315,   317,   317,   318,   318,   318,
2122	>	318,   318,   318,   318,   318,   318,   318,   318,   318,   318,
2123	>	318,   318,   318,   318,   318,   318,   318,   318,   318,   320,
2124	>	319,   321,   321,   322,   322,   322,   322,   322,   322,   322,
2125	>	322,   322,   322,   322,   322,   322,   322,   322,   322,   322,
2126	>	322,   322,   322,   322,   322,   322,   322,   322,   322,   322,
2127	>	322,   322,   324,   323,   325,   325,   326,   326,   326,   326,
2128	>	326,   326,   326,   326,   326,   326,   326,   326,   326,   326,
2129	>	326,   326,   327,   328,   329,   330,   331,   332,   333,   334,
2130	>	335,   336,   337,   338,   339,   340,   342,   341,   343,   343,
2131	>	344,   344,   346,   345,   348,   347,   349,   349,   350,   350,
2132	>	350,   350,   350,   351,   351,   352,   352,   352,   352,   352,
2133	>	354,   353,   355,   355,   356,   356,   357,   358,   360,   359,
2134	>	361,   361,   362,   362,   362,   362,   362,   362,   362,   362,
2135	>	362,   363,   364,   365,   366,   368,   367,   369,   369,   370,
2136	>	370,   370,   370,   370,   370,   370,   370,   370,   371,   372,
2137	>	373,   375,   374,   376,   376,   377,   377,   377,   377,   378,
2138	>	379,   380,   381,   382,   382,   383,   383,   384,   386,   385,
2139	>	387,   387,   388,   388,   388,   388,   389,   390,   392,   391,
2140	>	393,   393,   394,   394,   394,   394,   394,   394,   394,   394,
2141	>	394,   394,   396,   395,   397,   397,   398,   398,   398,   399,
2142	>	401,   400,   402,   402,   403,   403,   403,   403,   403,   403,
2143	>	403,   403,   403,   403,   405,   404,   406,   406,   407,   407,
2144	>	407,   407,   407,   407,   407,   407,   407,   407,   407,   407,
2145	>	407,   407,   407,   407,   408,   409,   410,   411,   412,   413,
2146	>	414,   415,   416,   416,   418,   417,   419,   419,   420,   420,
2147	>	421,   422,   423,   424,   425,   427,   426,   428,   428,   429,
2148	>	429,   429,   430,   431,   433,   432,   434,   434,   435,   435,
2149	>	435,   436,   437,   438,   439,   439,   440,   440,   441,   443,
2150	>	442,   444,   444,   445,   445,   445,   446,   447,   448,   449,
2151	>	449,   450,   450,   450,   450,   450,   450,   450,   450,   450,
2152	>	450,   450,   450,   450,   450,   450,   450,   450,   450,   450,
2153	>	450,   450,   450,   450,   450,   450,   450,   450,   450,   450,
2154	>	450,   450,   450,   450,   450,   450,   450,   450,   450,   450,
2155	>	450,   450,   450,   450,   450,   450,   450,   451,   452,   453,
2156	>	454,   455,   456,   457,   458,   459,   460,   461,   462,   463,
2157	>	464,   465,   466,   467,   468,   469,   470,   471,   472,   473,
2158	>	474,   475,   476,   477,   478,   479,   480,   481,   482,   483,
2159	>	484,   485,   486,   487,   488,   489,   491,   490,   492,   492,
2160	>	493,   493,   493,   493,   493,   493,   493,   493,   493,   493,
2161	>	493,   493,   493,   493,   493,   493,   493,   493,   493,   493,
2162	>	493,   493,   495,   494,   496,   496,   497,   497,   497,   497,
2163	>	497,   497,   497,   497,   497,   497,   497,   497,   497,   497,
2164	>	497,   497,   497,   497,   497,   497,   498,   499,   500,   501,
2165	>	502,   503,   503,   504,   504,   504,   504,   504,   504,   504,
2166	>	504,   504,   504,   504,   504,   504,   504,   504,   504,   505,
2167	>	506,   507,   508,   509,   510,   511,   512,   513,   514,   515,
2168	>	516,   517,   518,   519,   520,   521,   521,   522,   522,   522,
2169	>	522,   522,   522,   522,   522,   522,   522,   523,   524,   525,
2170	>	526,   527,   528,   529,   530,   531
2171	>	};
2172
2173	<	#define YYACCEPT        goto yyacceptlab
2174	<	#define YYABORT         goto yyabortlab
2175	<	#define YYERROR         goto yyerrorlab
2173	>	/* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
2174	>	static const yytype_int8 yyr2[] =
2175	>	{
2176	>	0,     2,     0,     2,     1,     1,     1,     1,     1,     1,
2177	>	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2178	>	1,     1,     1,     1,     1,     1,     2,     2,     0,     1,
2179	>	2,     3,     3,     3,     3,     3,     3,     3,     0,     1,
2180	>	2,     3,     3,     3,     5,     2,     1,     1,     1,     2,
2181	>	4,     4,     5,     2,     1,     1,     1,     1,     1,     1,
2182	>	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2183	>	1,     2,     4,     4,     4,     4,     4,     4,     4,     4,
2184	>	4,     4,     4,     4,     4,     4,     4,     4,     5,     2,
2185	>	1,     1,     1,     1,     2,     4,     4,     4,     0,     6,
2186	>	2,     1,     1,     1,     2,     4,     4,     0,     6,     2,
2187	>	1,     1,     1,     1,     1,     2,     4,     4,     4,     4,
2188	>	5,     2,     1,     1,     1,     2,     4,     0,     6,     2,
2189	>	1,     1,     1,     1,     2,     4,     4,     4,     0,     5,
2190	>	3,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2191	>	0,     6,     2,     1,     1,     1,     1,     1,     1,     1,
2192	>	1,     1,     1,     1,     2,     4,     4,     4,     4,     4,
2193	>	4,     4,     4,     0,     5,     3,     1,     1,     1,     1,
2194	>	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2195	>	1,     1,     1,     1,     1,     1,     1,     1,     1,     0,
2196	>	5,     3,     1,     3,     1,     3,     1,     3,     1,     1,
2197	>	1,     1,     1,     1,     1,     1,     1,     3,     1,     1,
2198	>	1,     1,     1,     1,     1,     1,     1,     3,     3,     1,
2199	>	1,     1,     0,     6,     2,     1,     1,     1,     1,     1,
2200	>	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2201	>	1,     2,     4,     4,     4,     4,     4,     4,     4,     4,
2202	>	4,     4,     4,     4,     4,     4,     0,     5,     3,     1,
2203	>	1,     1,     0,     6,     0,     5,     3,     1,     1,     1,
2204	>	1,     1,     1,     2,     1,     1,     1,     1,     1,     2,
2205	>	0,     5,     3,     1,     1,     3,     4,     4,     0,     6,
2206	>	2,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2207	>	2,     4,     4,     4,     4,     0,     5,     3,     1,     1,
2208	>	1,     1,     1,     1,     1,     1,     1,     1,     4,     4,
2209	>	4,     0,     6,     2,     1,     1,     1,     1,     2,     4,
2210	>	4,     4,     5,     2,     1,     1,     1,     4,     0,     6,
2211	>	2,     1,     1,     1,     1,     2,     4,     4,     0,     5,
2212	>	3,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2213	>	1,     1,     0,     6,     2,     1,     1,     1,     2,     4,
2214	>	0,     5,     3,     1,     1,     1,     1,     1,     1,     1,
2215	>	1,     1,     1,     1,     0,     6,     2,     1,     1,     1,
2216	>	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2217	>	1,     1,     1,     2,     4,     4,     4,     4,     4,     4,
2218	>	4,     4,     4,     4,     0,     5,     3,     1,     1,     1,
2219	>	4,     4,     4,     4,     4,     0,     6,     2,     1,     1,
2220	>	1,     1,     4,     4,     0,     6,     2,     1,     1,     1,
2221	>	1,     4,     4,     5,     2,     1,     1,     1,     4,     0,
2222	>	6,     2,     1,     1,     1,     1,     4,     4,     5,     2,
2223	>	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2224	>	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2225	>	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2226	>	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2227	>	1,     1,     1,     1,     1,     1,     1,     4,     4,     4,
2228	>	4,     4,     4,     4,     4,     4,     4,     4,     4,     4,
2229	>	4,     4,     4,     4,     4,     4,     4,     4,     4,     4,
2230	>	4,     4,     4,     4,     4,     4,     4,     4,     4,     4,
2231	>	4,     4,     4,     4,     4,     4,     0,     5,     3,     1,
2232	>	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2233	>	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2234	>	1,     1,     0,     5,     3,     1,     1,     1,     1,     1,
2235	>	1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2236	>	1,     1,     1,     1,     1,     1,     4,     4,     4,     4,
2237	>	5,     2,     1,     1,     1,     1,     1,     1,     1,     1,
2238	>	1,     1,     1,     1,     1,     1,     1,     1,     1,     4,
2239	>	4,     4,     4,     4,     4,     4,     4,     4,     4,     4,
2240	>	4,     4,     4,     4,     5,     2,     1,     1,     1,     1,
2241	>	1,     1,     1,     1,     1,     1,     1,     4,     4,     4,
2242	>	4,     4,     4,     4,     4,     4
2243	>	};
2244
2245
2246	<	/* Like YYERROR except do call yyerror.  This remains here temporarily
2247	<	to ease the transition to the new meaning of YYERROR, for GCC.
2248	<	Once GCC version 2 has supplanted version 1, this can go.  */
2246	>	#define yyerrok         (yyerrstatus = 0)
2247	>	#define yyclearin       (yychar = YYEMPTY)
2248	>	#define YYEMPTY         (-2)
2249	>	#define YYEOF           0
2250	>
2251	>	#define YYACCEPT        goto yyacceptlab
2252	>	#define YYABORT         goto yyabortlab
2253	>	#define YYERROR         goto yyerrorlab
2254
2668	–	#define YYFAIL          goto yyerrlab
2255
2256		#define YYRECOVERING()  (!!yyerrstatus)
2257
2258	<	#define YYBACKUP(Token, Value)                                  \
2259	<	do                                                              \
2260	<	if (yychar == YYEMPTY && yylen == 1)                          \
2261	<	{                                                           \
2262	<	yychar = (Token);                                         \
2263	<	yylval = (Value);                                         \
2264	<	yytoken = YYTRANSLATE (yychar);                           \
2265	<	YYPOPSTACK (1);                                           \
2266	<	goto yybackup;                                            \
2267	<	}                                                           \
2268	<	else                                                          \
2269	<	{                                                           \
2270	<	yyerror (YY_("syntax error: cannot back up")); \
2271	<	YYERROR;                                                  \
2272	<	}                                                           \
2273	<	while (YYID (0))
2274	<
2275	<
2276	<	#define YYTERROR        1
2277	<	#define YYERRCODE       256
2692	<
2693	<
2694	<	/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
2695	<	If N is 0, then set CURRENT to the empty location which ends
2696	<	the previous symbol: RHS[0] (always defined).  */
2697	<
2698	<	#define YYRHSLOC(Rhs, K) ((Rhs)[K])
2699	<	#ifndef YYLLOC_DEFAULT
2700	<	# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
2701	<	do                                                                  \
2702	<	if (YYID (N))                                                    \
2703	<	{                                                               \
2704	<	(Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
2705	<	(Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
2706	<	(Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
2707	<	(Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
2708	<	}                                                               \
2709	<	else                                                              \
2710	<	{                                                               \
2711	<	(Current).first_line   = (Current).last_line   =              \
2712	<	YYRHSLOC (Rhs, 0).last_line;                                \
2713	<	(Current).first_column = (Current).last_column =              \
2714	<	YYRHSLOC (Rhs, 0).last_column;                              \
2715	<	}                                                               \
2716	<	while (YYID (0))
2717	<	#endif
2718	<
2258	>	#define YYBACKUP(Token, Value)                                    \
2259	>	do                                                              \
2260	>	if (yychar == YYEMPTY)                                        \
2261	>	{                                                           \
2262	>	yychar = (Token);                                         \
2263	>	yylval = (Value);                                         \
2264	>	YYPOPSTACK (yylen);                                       \
2265	>	yystate = *yyssp;                                         \
2266	>	goto yybackup;                                            \
2267	>	}                                                           \
2268	>	else                                                          \
2269	>	{                                                           \
2270	>	yyerror (YY_("syntax error: cannot back up")); \
2271	>	YYERROR;                                                  \
2272	>	}                                                           \
2273	>	while (0)
2274	>
2275	>	/* Error token number */
2276	>	#define YYTERROR        1
2277	>	#define YYERRCODE       256
2278
2720	–	/* YY_LOCATION_PRINT -- Print the location on the stream.
2721	–	This macro was not mandated originally: define only if we know
2722	–	we won't break user code: when these are the locations we know.  */
2723	–
2724	–	#ifndef YY_LOCATION_PRINT
2725	–	# if YYLTYPE_IS_TRIVIAL
2726	–	#  define YY_LOCATION_PRINT(File, Loc)                  \
2727	–	fprintf (File, "%d.%d-%d.%d",                      \
2728	–	(Loc).first_line, (Loc).first_column,     \
2729	–	(Loc).last_line,  (Loc).last_column)
2730	–	# else
2731	–	#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
2732	–	# endif
2733	–	#endif
2279
2280
2736	–	/* YYLEX -- calling `yylex' with the right arguments.  */
2737	–
2738	–	#ifdef YYLEX_PARAM
2739	–	# define YYLEX yylex (YYLEX_PARAM)
2740	–	#else
2741	–	# define YYLEX yylex ()
2742	–	#endif
2743	–
2281		/* Enable debugging if requested.  */
2282		#if YYDEBUG
2283
#	Line 2749 | Line 2286 | while (YYID (0))
2286		#  define YYFPRINTF fprintf
2287		# endif
2288
2289	<	# define YYDPRINTF(Args)                        \
2290	<	do {                                            \
2291	<	if (yydebug)                                  \
2292	<	YYFPRINTF Args;                             \
2293	<	} while (YYID (0))
2294	<
2295	<	# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
2296	<	do {                                                                      \
2297	<	if (yydebug)                                                            \
2761	<	{                                                                     \
2762	<	YYFPRINTF (stderr, "%s ", Title);                                   \
2763	<	yy_symbol_print (stderr,                                            \
2764	<	Type, Value); \
2765	<	YYFPRINTF (stderr, "\n");                                           \
2766	<	}                                                                     \
2767	<	} while (YYID (0))
2768	<
2769	<
2770	<	/*--------------------------------.
2771	<	| Print this symbol on YYOUTPUT.  |
2772	<	`--------------------------------*/
2773	<
2774	<	/*ARGSUSED*/
2775	<	#if (defined __STDC__ || defined __C99__FUNC__ \
2776	<	|| defined __cplusplus || defined _MSC_VER)
2777	<	static void
2778	<	yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
2779	<	#else
2780	<	static void
2781	<	yy_symbol_value_print (yyoutput, yytype, yyvaluep)
2782	<	FILE *yyoutput;
2783	<	int yytype;
2784	<	YYSTYPE const * const yyvaluep;
2289	>	# define YYDPRINTF(Args)                        \
2290	>	do {                                            \
2291	>	if (yydebug)                                  \
2292	>	YYFPRINTF Args;                             \
2293	>	} while (0)
2294	>
2295	>	/* This macro is provided for backward compatibility. */
2296	>	#ifndef YY_LOCATION_PRINT
2297	>	# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
2298		#endif
2299	+
2300	+
2301	+	# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
2302	+	do {                                                                      \
2303	+	if (yydebug)                                                            \
2304	+	{                                                                     \
2305	+	YYFPRINTF (stderr, "%s ", Title);                                   \
2306	+	yy_symbol_print (stderr,                                            \
2307	+	Type, Value); \
2308	+	YYFPRINTF (stderr, "\n");                                           \
2309	+	}                                                                     \
2310	+	} while (0)
2311	+
2312	+
2313	+	/*-----------------------------------.
2314	+	| Print this symbol's value on YYO.  |
2315	+	`-----------------------------------*/
2316	+
2317	+	static void
2318	+	yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)
2319		{
2320	+	FILE *yyoutput = yyo;
2321	+	YYUSE (yyoutput);
2322		if (!yyvaluep)
2323		return;
2324		# ifdef YYPRINT
2325		if (yytype < YYNTOKENS)
2326	<	YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
2792	<	# else
2793	<	YYUSE (yyoutput);
2326	>	YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
2327		# endif
2328	<	switch (yytype)
2329	<	{
2330	<	default:
2798	<	break;
2799	<	}
2328	>	YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2329	>	YYUSE (yytype);
2330	>	YY_IGNORE_MAYBE_UNINITIALIZED_END
2331		}
2332
2333
2334	<	/*--------------------------------.
2335	<	| Print this symbol on YYOUTPUT.  |
2336	<	`--------------------------------*/
2334	>	/*---------------------------.
2335	>	| Print this symbol on YYO.  |
2336	>	`---------------------------*/
2337
2807	–	#if (defined __STDC__ || defined __C99__FUNC__ \
2808	–	|| defined __cplusplus || defined _MSC_VER)
2338		static void
2339	<	yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
2811	<	#else
2812	<	static void
2813	<	yy_symbol_print (yyoutput, yytype, yyvaluep)
2814	<	FILE *yyoutput;
2815	<	int yytype;
2816	<	YYSTYPE const * const yyvaluep;
2817	<	#endif
2339	>	yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)
2340		{
2341	<	if (yytype < YYNTOKENS)
2342	<	YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
2821	<	else
2822	<	YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
2341	>	YYFPRINTF (yyo, "%s %s (",
2342	>	yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
2343
2344	<	yy_symbol_value_print (yyoutput, yytype, yyvaluep);
2345	<	YYFPRINTF (yyoutput, ")");
2344	>	yy_symbol_value_print (yyo, yytype, yyvaluep);
2345	>	YYFPRINTF (yyo, ")");
2346		}
2347
2348		/*------------------------------------------------------------------.
#	Line 2830 | Line 2350 | yy_symbol_print (yyoutput, yytype, yyval
2350		| TOP (included).                                                   |
2351		`------------------------------------------------------------------*/
2352
2833	–	#if (defined __STDC__ || defined __C99__FUNC__ \
2834	–	|| defined __cplusplus || defined _MSC_VER)
2353		static void
2354	<	yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
2837	<	#else
2838	<	static void
2839	<	yy_stack_print (yybottom, yytop)
2840	<	yytype_int16 *yybottom;
2841	<	yytype_int16 *yytop;
2842	<	#endif
2354	>	yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
2355		{
2356		YYFPRINTF (stderr, "Stack now");
2357		for (; yybottom <= yytop; yybottom++)
#	Line 2850 | Line 2362 | yy_stack_print (yybottom, yytop)
2362		YYFPRINTF (stderr, "\n");
2363		}
2364
2365	<	# define YY_STACK_PRINT(Bottom, Top)                            \
2366	<	do {                                                            \
2367	<	if (yydebug)                                                  \
2368	<	yy_stack_print ((Bottom), (Top));                           \
2369	<	} while (YYID (0))
2365	>	# define YY_STACK_PRINT(Bottom, Top)                            \
2366	>	do {                                                            \
2367	>	if (yydebug)                                                  \
2368	>	yy_stack_print ((Bottom), (Top));                           \
2369	>	} while (0)
2370
2371
2372		/*------------------------------------------------.
2373		| Report that the YYRULE is going to be reduced.  |
2374		`------------------------------------------------*/
2375
2864	–	#if (defined __STDC__ || defined __C99__FUNC__ \
2865	–	|| defined __cplusplus || defined _MSC_VER)
2376		static void
2377	<	yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
2868	<	#else
2869	<	static void
2870	<	yy_reduce_print (yyvsp, yyrule)
2871	<	YYSTYPE *yyvsp;
2872	<	int yyrule;
2873	<	#endif
2377	>	yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, int yyrule)
2378		{
2379	+	int yylno = yyrline[yyrule];
2380		int yynrhs = yyr2[yyrule];
2381		int yyi;
2382	<	unsigned long int yylno = yyrline[yyrule];
2383	<	YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
2879	<	yyrule - 1, yylno);
2382	>	YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
2383	>	yyrule - 1, yylno);
2384		/* The symbols being reduced.  */
2385		for (yyi = 0; yyi < yynrhs; yyi++)
2386		{
2387		YYFPRINTF (stderr, "   $%d = ", yyi + 1);
2388	<	yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
2389	<	&(yyvsp[(yyi + 1) - (yynrhs)])
2390	<	);
2388	>	yy_symbol_print (stderr,
2389	>	yystos[+yyssp[yyi + 1 - yynrhs]],
2390	>	&yyvsp[(yyi + 1) - (yynrhs)]
2391	>	);
2392		YYFPRINTF (stderr, "\n");
2393		}
2394		}
2395
2396	<	# define YY_REDUCE_PRINT(Rule)          \
2397	<	do {                                    \
2398	<	if (yydebug)                          \
2399	<	yy_reduce_print (yyvsp, Rule); \
2400	<	} while (YYID (0))
2396	>	# define YY_REDUCE_PRINT(Rule)          \
2397	>	do {                                    \
2398	>	if (yydebug)                          \
2399	>	yy_reduce_print (yyssp, yyvsp, Rule); \
2400	>	} while (0)
2401
2402		/* Nonzero means print parse trace.  It is left uninitialized so that
2403		multiple parsers can coexist.  */
#	Line 2906 | Line 2411 | int yydebug;
2411
2412
2413		/* YYINITDEPTH -- initial size of the parser's stacks.  */
2414	<	#ifndef YYINITDEPTH
2414	>	#ifndef YYINITDEPTH
2415		# define YYINITDEPTH 200
2416		#endif
2417
#	Line 2921 | Line 2426 | int yydebug;
2426		# define YYMAXDEPTH 10000
2427		#endif
2428
2924	–
2429
2430		#if YYERROR_VERBOSE
2431
2432		# ifndef yystrlen
2433		#  if defined __GLIBC__ && defined _STRING_H
2434	<	#   define yystrlen strlen
2434	>	#   define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S)))
2435		#  else
2436		/* Return the length of YYSTR.  */
2437	<	#if (defined __STDC__ || defined __C99__FUNC__ \
2934	<	|| defined __cplusplus || defined _MSC_VER)
2935	<	static YYSIZE_T
2437	>	static YYPTRDIFF_T
2438		yystrlen (const char *yystr)
2937	–	#else
2938	–	static YYSIZE_T
2939	–	yystrlen (yystr)
2940	–	const char *yystr;
2941	–	#endif
2439		{
2440	<	YYSIZE_T yylen;
2440	>	YYPTRDIFF_T yylen;
2441		for (yylen = 0; yystr[yylen]; yylen++)
2442		continue;
2443		return yylen;
#	Line 2954 | Line 2451 | yystrlen (yystr)
2451		#  else
2452		/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
2453		YYDEST.  */
2957	–	#if (defined __STDC__ || defined __C99__FUNC__ \
2958	–	|| defined __cplusplus || defined _MSC_VER)
2454		static char *
2455		yystpcpy (char *yydest, const char *yysrc)
2961	–	#else
2962	–	static char *
2963	–	yystpcpy (yydest, yysrc)
2964	–	char *yydest;
2965	–	const char *yysrc;
2966	–	#endif
2456		{
2457		char *yyd = yydest;
2458		const char *yys = yysrc;
#	Line 2984 | Line 2473 | yystpcpy (yydest, yysrc)
2473		backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
2474		null, do not copy; instead, return the length of what the result
2475		would have been.  */
2476	<	static YYSIZE_T
2476	>	static YYPTRDIFF_T
2477		yytnamerr (char *yyres, const char *yystr)
2478		{
2479		if (*yystr == '"')
2480		{
2481	<	YYSIZE_T yyn = 0;
2481	>	YYPTRDIFF_T yyn = 0;
2482		char const *yyp = yystr;
2483
2484		for (;;)
2485	<	switch (*++yyp)
2486	<	{
2487	<	case '\'':
2488	<	case ',':
2489	<	goto do_not_strip_quotes;
2490	<
2491	<	case '\\':
2492	<	if (*++yyp != '\\')
2493	<	goto do_not_strip_quotes;
2494	<	/* Fall through.  */
2495	<	default:
2496	<	if (yyres)
2497	<	yyres[yyn] = *yyp;
2498	<	yyn++;
2499	<	break;
2500	<
2501	<	case '"':
2502	<	if (yyres)
2503	<	yyres[yyn] = '\0';
2504	<	return yyn;
2505	<	}
2485	>	switch (*++yyp)
2486	>	{
2487	>	case '\'':
2488	>	case ',':
2489	>	goto do_not_strip_quotes;
2490	>
2491	>	case '\\':
2492	>	if (*++yyp != '\\')
2493	>	goto do_not_strip_quotes;
2494	>	else
2495	>	goto append;
2496	>
2497	>	append:
2498	>	default:
2499	>	if (yyres)
2500	>	yyres[yyn] = *yyp;
2501	>	yyn++;
2502	>	break;
2503	>
2504	>	case '"':
2505	>	if (yyres)
2506	>	yyres[yyn] = '\0';
2507	>	return yyn;
2508	>	}
2509		do_not_strip_quotes: ;
2510		}
2511
2512	<	if (! yyres)
2512	>	if (yyres)
2513	>	return yystpcpy (yyres, yystr) - yyres;
2514	>	else
2515		return yystrlen (yystr);
3022	–
3023	–	return yystpcpy (yyres, yystr) - yyres;
2516		}
2517		# endif
2518
2519	<	/* Copy into YYRESULT an error message about the unexpected token
2520	<	YYCHAR while in state YYSTATE.  Return the number of bytes copied,
2521	<	including the terminating null byte.  If YYRESULT is null, do not
2522	<	copy anything; just return the number of bytes that would be
2523	<	copied.  As a special case, return 0 if an ordinary "syntax error"
2524	<	message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
2525	<	size calculation.  */
2526	<	static YYSIZE_T
2527	<	yysyntax_error (char *yyresult, int yystate, int yychar)
2519	>	/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
2520	>	about the unexpected token YYTOKEN for the state stack whose top is
2521	>	YYSSP.
2522	>
2523	>	Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
2524	>	not large enough to hold the message.  In that case, also set
2525	>	*YYMSG_ALLOC to the required number of bytes.  Return 2 if the
2526	>	required number of bytes is too large to store.  */
2527	>	static int
2528	>	yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg,
2529	>	yy_state_t *yyssp, int yytoken)
2530		{
2531	<	int yyn = yypact[yystate];
2531	>	enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
2532	>	/* Internationalized format string. */
2533	>	const char *yyformat = YY_NULLPTR;
2534	>	/* Arguments of yyformat: reported tokens (one for the "unexpected",
2535	>	one per "expected"). */
2536	>	char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
2537	>	/* Actual size of YYARG. */
2538	>	int yycount = 0;
2539	>	/* Cumulated lengths of YYARG.  */
2540	>	YYPTRDIFF_T yysize = 0;
2541	>
2542	>	/* There are many possibilities here to consider:
2543	>	- If this state is a consistent state with a default action, then
2544	>	the only way this function was invoked is if the default action
2545	>	is an error action.  In that case, don't check for expected
2546	>	tokens because there are none.
2547	>	- The only way there can be no lookahead present (in yychar) is if
2548	>	this state is a consistent state with a default action.  Thus,
2549	>	detecting the absence of a lookahead is sufficient to determine
2550	>	that there is no unexpected or expected token to report.  In that
2551	>	case, just report a simple "syntax error".
2552	>	- Don't assume there isn't a lookahead just because this state is a
2553	>	consistent state with a default action.  There might have been a
2554	>	previous inconsistent state, consistent state with a non-default
2555	>	action, or user semantic action that manipulated yychar.
2556	>	- Of course, the expected token list depends on states to have
2557	>	correct lookahead information, and it depends on the parser not
2558	>	to perform extra reductions after fetching a lookahead from the
2559	>	scanner and before detecting a syntax error.  Thus, state merging
2560	>	(from LALR or IELR) and default reductions corrupt the expected
2561	>	token list.  However, the list is correct for canonical LR with
2562	>	one exception: it will still contain any token that will not be
2563	>	accepted due to an error action in a later state.
2564	>	*/
2565	>	if (yytoken != YYEMPTY)
2566	>	{
2567	>	int yyn = yypact[+*yyssp];
2568	>	YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
2569	>	yysize = yysize0;
2570	>	yyarg[yycount++] = yytname[yytoken];
2571	>	if (!yypact_value_is_default (yyn))
2572	>	{
2573	>	/* Start YYX at -YYN if negative to avoid negative indexes in
2574	>	YYCHECK.  In other words, skip the first -YYN actions for
2575	>	this state because they are default actions.  */
2576	>	int yyxbegin = yyn < 0 ? -yyn : 0;
2577	>	/* Stay within bounds of both yycheck and yytname.  */
2578	>	int yychecklim = YYLAST - yyn + 1;
2579	>	int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
2580	>	int yyx;
2581	>
2582	>	for (yyx = yyxbegin; yyx < yyxend; ++yyx)
2583	>	if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
2584	>	&& !yytable_value_is_error (yytable[yyx + yyn]))
2585	>	{
2586	>	if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
2587	>	{
2588	>	yycount = 1;
2589	>	yysize = yysize0;
2590	>	break;
2591	>	}
2592	>	yyarg[yycount++] = yytname[yyx];
2593	>	{
2594	>	YYPTRDIFF_T yysize1
2595	>	= yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
2596	>	if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
2597	>	yysize = yysize1;
2598	>	else
2599	>	return 2;
2600	>	}
2601	>	}
2602	>	}
2603	>	}
2604
2605	<	if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
3040	<	return 0;
3041	<	else
2605	>	switch (yycount)
2606		{
2607	<	int yytype = YYTRANSLATE (yychar);
2608	<	YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
2609	<	YYSIZE_T yysize = yysize0;
2610	<	YYSIZE_T yysize1;
2611	<	int yysize_overflow = 0;
2612	<	enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
2613	<	char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
2614	<	int yyx;
2615	<
2616	<	# if 0
2617	<	/* This is so xgettext sees the translatable formats that are
2618	<	constructed on the fly.  */
2619	<	YY_("syntax error, unexpected %s");
3056	<	YY_("syntax error, unexpected %s, expecting %s");
3057	<	YY_("syntax error, unexpected %s, expecting %s or %s");
3058	<	YY_("syntax error, unexpected %s, expecting %s or %s or %s");
3059	<	YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
3060	<	# endif
3061	<	char *yyfmt;
3062	<	char const *yyf;
3063	<	static char const yyunexpected[] = "syntax error, unexpected %s";
3064	<	static char const yyexpecting[] = ", expecting %s";
3065	<	static char const yyor[] = " or %s";
3066	<	char yyformat[sizeof yyunexpected
3067	<	+ sizeof yyexpecting - 1
3068	<	+ ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
3069	<	* (sizeof yyor - 1))];
3070	<	char const *yyprefix = yyexpecting;
3071	<
3072	<	/* Start YYX at -YYN if negative to avoid negative indexes in
3073	<	YYCHECK.  */
3074	<	int yyxbegin = yyn < 0 ? -yyn : 0;
3075	<
3076	<	/* Stay within bounds of both yycheck and yytname.  */
3077	<	int yychecklim = YYLAST - yyn + 1;
3078	<	int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
3079	<	int yycount = 1;
3080	<
3081	<	yyarg[0] = yytname[yytype];
3082	<	yyfmt = yystpcpy (yyformat, yyunexpected);
3083	<
3084	<	for (yyx = yyxbegin; yyx < yyxend; ++yyx)
3085	<	if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
3086	<	{
3087	<	if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
3088	<	{
3089	<	yycount = 1;
3090	<	yysize = yysize0;
3091	<	yyformat[sizeof yyunexpected - 1] = '\0';
3092	<	break;
3093	<	}
3094	<	yyarg[yycount++] = yytname[yyx];
3095	<	yysize1 = yysize + yytnamerr (0, yytname[yyx]);
3096	<	yysize_overflow |= (yysize1 < yysize);
3097	<	yysize = yysize1;
3098	<	yyfmt = yystpcpy (yyfmt, yyprefix);
3099	<	yyprefix = yyor;
3100	<	}
3101	<
3102	<	yyf = YY_(yyformat);
3103	<	yysize1 = yysize + yystrlen (yyf);
3104	<	yysize_overflow |= (yysize1 < yysize);
3105	<	yysize = yysize1;
2607	>	# define YYCASE_(N, S)                      \
2608	>	case N:                               \
2609	>	yyformat = S;                       \
2610	>	break
2611	>	default: /* Avoid compiler warnings. */
2612	>	YYCASE_(0, YY_("syntax error"));
2613	>	YYCASE_(1, YY_("syntax error, unexpected %s"));
2614	>	YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
2615	>	YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
2616	>	YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
2617	>	YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
2618	>	# undef YYCASE_
2619	>	}
2620
2621	<	if (yysize_overflow)
2622	<	return YYSIZE_MAXIMUM;
2621	>	{
2622	>	/* Don't count the "%s"s in the final size, but reserve room for
2623	>	the terminator.  */
2624	>	YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1;
2625	>	if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
2626	>	yysize = yysize1;
2627	>	else
2628	>	return 2;
2629	>	}
2630
2631	<	if (yyresult)
2632	<	{
2633	<	/* Avoid sprintf, as that infringes on the user's name space.
2634	<	Don't have undefined behavior even if the translation
2635	<	produced a string with the wrong number of "%s"s.  */
2636	<	char *yyp = yyresult;
2637	<	int yyi = 0;
3117	<	while ((*yyp = *yyf) != '\0')
3118	<	{
3119	<	if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
3120	<	{
3121	<	yyp += yytnamerr (yyp, yyarg[yyi++]);
3122	<	yyf += 2;
3123	<	}
3124	<	else
3125	<	{
3126	<	yyp++;
3127	<	yyf++;
3128	<	}
3129	<	}
3130	<	}
3131	<	return yysize;
2631	>	if (*yymsg_alloc < yysize)
2632	>	{
2633	>	*yymsg_alloc = 2 * yysize;
2634	>	if (! (yysize <= *yymsg_alloc
2635	>	&& *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
2636	>	*yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
2637	>	return 1;
2638		}
2639	+
2640	+	/* Avoid sprintf, as that infringes on the user's name space.
2641	+	Don't have undefined behavior even if the translation
2642	+	produced a string with the wrong number of "%s"s.  */
2643	+	{
2644	+	char *yyp = *yymsg;
2645	+	int yyi = 0;
2646	+	while ((*yyp = *yyformat) != '\0')
2647	+	if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
2648	+	{
2649	+	yyp += yytnamerr (yyp, yyarg[yyi++]);
2650	+	yyformat += 2;
2651	+	}
2652	+	else
2653	+	{
2654	+	++yyp;
2655	+	++yyformat;
2656	+	}
2657	+	}
2658	+	return 0;
2659		}
2660		#endif /* YYERROR_VERBOSE */
3135	–
2661
2662		/*-----------------------------------------------.
2663		| Release the memory associated to this symbol.  |
2664		`-----------------------------------------------*/
2665
3141	–	/*ARGSUSED*/
3142	–	#if (defined __STDC__ || defined __C99__FUNC__ \
3143	–	|| defined __cplusplus || defined _MSC_VER)
2666		static void
2667		yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
3146	–	#else
3147	–	static void
3148	–	yydestruct (yymsg, yytype, yyvaluep)
3149	–	const char *yymsg;
3150	–	int yytype;
3151	–	YYSTYPE *yyvaluep;
3152	–	#endif
2668		{
2669		YYUSE (yyvaluep);
3155	–
2670		if (!yymsg)
2671		yymsg = "Deleting";
2672		YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
2673
2674	<	switch (yytype)
2675	<	{
2676	<
3163	<	default:
3164	<	break;
3165	<	}
2674	>	YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2675	>	YYUSE (yytype);
2676	>	YY_IGNORE_MAYBE_UNINITIALIZED_END
2677		}
2678
2679	<	/* Prevent warnings from -Wmissing-prototypes.  */
3169	<	#ifdef YYPARSE_PARAM
3170	<	#if defined __STDC__ || defined __cplusplus
3171	<	int yyparse (void *YYPARSE_PARAM);
3172	<	#else
3173	<	int yyparse ();
3174	<	#endif
3175	<	#else /* ! YYPARSE_PARAM */
3176	<	#if defined __STDC__ || defined __cplusplus
3177	<	int yyparse (void);
3178	<	#else
3179	<	int yyparse ();
3180	<	#endif
3181	<	#endif /* ! YYPARSE_PARAM */
2679	>
2680
2681
2682		/* The lookahead symbol.  */
#	Line 3186 | Line 2684 | int yychar;
2684
2685		/* The semantic value of the lookahead symbol.  */
2686		YYSTYPE yylval;
3189	–
2687		/* Number of syntax errors so far.  */
2688		int yynerrs;
2689
2690
2691	+	/*----------.
2692	+	| yyparse.  |
2693	+	`----------*/
2694
3195	–	/*-------------------------.
3196	–	| yyparse or yypush_parse.  |
3197	–	`-------------------------*/
3198	–
3199	–	#ifdef YYPARSE_PARAM
3200	–	#if (defined __STDC__ || defined __C99__FUNC__ \
3201	–	|| defined __cplusplus || defined _MSC_VER)
3202	–	int
3203	–	yyparse (void *YYPARSE_PARAM)
3204	–	#else
3205	–	int
3206	–	yyparse (YYPARSE_PARAM)
3207	–	void *YYPARSE_PARAM;
3208	–	#endif
3209	–	#else /* ! YYPARSE_PARAM */
3210	–	#if (defined __STDC__ || defined __C99__FUNC__ \
3211	–	|| defined __cplusplus || defined _MSC_VER)
2695		int
2696		yyparse (void)
3214	–	#else
3215	–	int
3216	–	yyparse ()
3217	–
3218	–	#endif
3219	–	#endif
2697		{
2698	<
3222	<
3223	<	int yystate;
2698	>	yy_state_fast_t yystate;
2699		/* Number of tokens to shift before error messages enabled.  */
2700		int yyerrstatus;
2701
2702		/* The stacks and their tools:
2703	<	`yyss': related to states.
2704	<	`yyvs': related to semantic values.
2703	>	'yyss': related to states.
2704	>	'yyvs': related to semantic values.
2705
2706	<	Refer to the stacks thru separate pointers, to allow yyoverflow
2706	>	Refer to the stacks through separate pointers, to allow yyoverflow
2707		to reallocate them elsewhere.  */
2708
2709		/* The state stack.  */
2710	<	yytype_int16 yyssa[YYINITDEPTH];
2711	<	yytype_int16 *yyss;
2712	<	yytype_int16 *yyssp;
2710	>	yy_state_t yyssa[YYINITDEPTH];
2711	>	yy_state_t *yyss;
2712	>	yy_state_t *yyssp;
2713
2714		/* The semantic value stack.  */
2715		YYSTYPE yyvsa[YYINITDEPTH];
2716		YYSTYPE *yyvs;
2717		YYSTYPE *yyvsp;
2718
2719	<	YYSIZE_T yystacksize;
2719	>	YYPTRDIFF_T yystacksize;
2720
2721		int yyn;
2722		int yyresult;
2723		/* Lookahead token as an internal (translated) token number.  */
2724	<	int yytoken;
2724	>	int yytoken = 0;
2725		/* The variables used to return semantic value and location from the
2726		action routines.  */
2727		YYSTYPE yyval;
#	Line 3255 | Line 2730 | yyparse ()
2730		/* Buffer for error messages, and its allocated size.  */
2731		char yymsgbuf[128];
2732		char *yymsg = yymsgbuf;
2733	<	YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
2733	>	YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
2734		#endif
2735
2736		#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
#	Line 3264 | Line 2739 | yyparse ()
2739		Keep to zero when no symbol should be popped.  */
2740		int yylen = 0;
2741
2742	<	yytoken = 0;
2743	<	yyss = yyssa;
3269	<	yyvs = yyvsa;
2742	>	yyssp = yyss = yyssa;
2743	>	yyvsp = yyvs = yyvsa;
2744		yystacksize = YYINITDEPTH;
2745
2746		YYDPRINTF ((stderr, "Starting parse\n"));
#	Line 3275 | Line 2749 | yyparse ()
2749		yyerrstatus = 0;
2750		yynerrs = 0;
2751		yychar = YYEMPTY; /* Cause a token to be read.  */
3278	–
3279	–	/* Initialize stack pointers.
3280	–	Waste one element of value and location stack
3281	–	so that they stay on the same level as the state stack.
3282	–	The wasted elements are never initialized.  */
3283	–	yyssp = yyss;
3284	–	yyvsp = yyvs;
3285	–
2752		goto yysetstate;
2753
2754	+
2755		/*------------------------------------------------------------.
2756	<	| yynewstate -- Push a new state, which is found in yystate.  |
2756	>	| yynewstate -- push a new state, which is found in yystate.  |
2757		`------------------------------------------------------------*/
2758	<	yynewstate:
2758	>	yynewstate:
2759		/* In all cases, when you get here, the value and location stacks
2760		have just been pushed.  So pushing a state here evens the stacks.  */
2761		yyssp++;
2762
2763	<	yysetstate:
2764	<	*yyssp = yystate;
2763	>
2764	>	/*--------------------------------------------------------------------.
2765	>	| yysetstate -- set current state (the top of the stack) to yystate.  |
2766	>	`--------------------------------------------------------------------*/
2767	>	yysetstate:
2768	>	YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2769	>	YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
2770	>	YY_IGNORE_USELESS_CAST_BEGIN
2771	>	*yyssp = YY_CAST (yy_state_t, yystate);
2772	>	YY_IGNORE_USELESS_CAST_END
2773
2774		if (yyss + yystacksize - 1 <= yyssp)
2775	+	#if !defined yyoverflow && !defined YYSTACK_RELOCATE
2776	+	goto yyexhaustedlab;
2777	+	#else
2778		{
2779		/* Get the current used size of the three stacks, in elements.  */
2780	<	YYSIZE_T yysize = yyssp - yyss + 1;
2780	>	YYPTRDIFF_T yysize = yyssp - yyss + 1;
2781
2782	<	#ifdef yyoverflow
2782	>	# if defined yyoverflow
2783		{
2784	<	/* Give user a chance to reallocate the stack.  Use copies of
2785	<	these so that the &'s don't force the real ones into
2786	<	memory.  */
2787	<	YYSTYPE *yyvs1 = yyvs;
2788	<	yytype_int16 *yyss1 = yyss;
2789	<
2790	<	/* Each stack pointer address is followed by the size of the
2791	<	data in use in that stack, in bytes.  This used to be a
2792	<	conditional around just the two extra args, but that might
2793	<	be undefined if yyoverflow is a macro.  */
2794	<	yyoverflow (YY_("memory exhausted"),
2795	<	&yyss1, yysize * sizeof (*yyssp),
2796	<	&yyvs1, yysize * sizeof (*yyvsp),
2797	<	&yystacksize);
2798	<
2799	<	yyss = yyss1;
3322	<	yyvs = yyvs1;
2784	>	/* Give user a chance to reallocate the stack.  Use copies of
2785	>	these so that the &'s don't force the real ones into
2786	>	memory.  */
2787	>	yy_state_t *yyss1 = yyss;
2788	>	YYSTYPE *yyvs1 = yyvs;
2789	>
2790	>	/* Each stack pointer address is followed by the size of the
2791	>	data in use in that stack, in bytes.  This used to be a
2792	>	conditional around just the two extra args, but that might
2793	>	be undefined if yyoverflow is a macro.  */
2794	>	yyoverflow (YY_("memory exhausted"),
2795	>	&yyss1, yysize * YYSIZEOF (*yyssp),
2796	>	&yyvs1, yysize * YYSIZEOF (*yyvsp),
2797	>	&yystacksize);
2798	>	yyss = yyss1;
2799	>	yyvs = yyvs1;
2800		}
2801	<	#else /* no yyoverflow */
3325	<	# ifndef YYSTACK_RELOCATE
3326	<	goto yyexhaustedlab;
3327	<	# else
2801	>	# else /* defined YYSTACK_RELOCATE */
2802		/* Extend the stack our own way.  */
2803		if (YYMAXDEPTH <= yystacksize)
2804	<	goto yyexhaustedlab;
2804	>	goto yyexhaustedlab;
2805		yystacksize *= 2;
2806		if (YYMAXDEPTH < yystacksize)
2807	<	yystacksize = YYMAXDEPTH;
2807	>	yystacksize = YYMAXDEPTH;
2808
2809		{
2810	<	yytype_int16 *yyss1 = yyss;
2811	<	union yyalloc *yyptr =
2812	<	(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2813	<	if (! yyptr)
2814	<	goto yyexhaustedlab;
2815	<	YYSTACK_RELOCATE (yyss_alloc, yyss);
2816	<	YYSTACK_RELOCATE (yyvs_alloc, yyvs);
2817	<	#  undef YYSTACK_RELOCATE
2818	<	if (yyss1 != yyssa)
2819	<	YYSTACK_FREE (yyss1);
2810	>	yy_state_t *yyss1 = yyss;
2811	>	union yyalloc *yyptr =
2812	>	YY_CAST (union yyalloc *,
2813	>	YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
2814	>	if (! yyptr)
2815	>	goto yyexhaustedlab;
2816	>	YYSTACK_RELOCATE (yyss_alloc, yyss);
2817	>	YYSTACK_RELOCATE (yyvs_alloc, yyvs);
2818	>	# undef YYSTACK_RELOCATE
2819	>	if (yyss1 != yyssa)
2820	>	YYSTACK_FREE (yyss1);
2821		}
2822		# endif
3348	–	#endif /* no yyoverflow */
2823
2824		yyssp = yyss + yysize - 1;
2825		yyvsp = yyvs + yysize - 1;
2826
2827	<	YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2828	<	(unsigned long int) yystacksize));
2827	>	YY_IGNORE_USELESS_CAST_BEGIN
2828	>	YYDPRINTF ((stderr, "Stack size increased to %ld\n",
2829	>	YY_CAST (long, yystacksize)));
2830	>	YY_IGNORE_USELESS_CAST_END
2831
2832		if (yyss + yystacksize - 1 <= yyssp)
2833	<	YYABORT;
2833	>	YYABORT;
2834		}
2835	<
3360	<	YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2835	>	#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
2836
2837		if (yystate == YYFINAL)
2838		YYACCEPT;
2839
2840		goto yybackup;
2841
2842	+
2843		/*-----------.
2844		| yybackup.  |
2845		`-----------*/
2846		yybackup:
3371	–
2847		/* Do appropriate processing given the current state.  Read a
2848		lookahead token if we need one and don't already have one.  */
2849
2850		/* First try to decide what to do without reference to lookahead token.  */
2851		yyn = yypact[yystate];
2852	<	if (yyn == YYPACT_NINF)
2852	>	if (yypact_value_is_default (yyn))
2853		goto yydefault;
2854
2855		/* Not known => get a lookahead token if don't already have one.  */
#	Line 3383 | Line 2858 | yybackup:
2858		if (yychar == YYEMPTY)
2859		{
2860		YYDPRINTF ((stderr, "Reading a token: "));
2861	<	yychar = YYLEX;
2861	>	yychar = yylex ();
2862		}
2863
2864		if (yychar <= YYEOF)
#	Line 3405 | Line 2880 | yybackup:
2880		yyn = yytable[yyn];
2881		if (yyn <= 0)
2882		{
2883	<	if (yyn == 0 || yyn == YYTABLE_NINF)
2884	<	goto yyerrlab;
2883	>	if (yytable_value_is_error (yyn))
2884	>	goto yyerrlab;
2885		yyn = -yyn;
2886		goto yyreduce;
2887		}
#	Line 3418 | Line 2893 | yybackup:
2893
2894		/* Shift the lookahead token.  */
2895		YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
3421	–
3422	–	/* Discard the shifted token.  */
3423	–	yychar = YYEMPTY;
3424	–
2896		yystate = yyn;
2897	+	YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2898		*++yyvsp = yylval;
2899	+	YY_IGNORE_MAYBE_UNINITIALIZED_END
2900
2901	+	/* Discard the shifted token.  */
2902	+	yychar = YYEMPTY;
2903		goto yynewstate;
2904
2905
#	Line 3439 | Line 2914 | yydefault:
2914
2915
2916		/*-----------------------------.
2917	<	| yyreduce -- Do a reduction.  |
2917	>	| yyreduce -- do a reduction.  |
2918		`-----------------------------*/
2919		yyreduce:
2920		/* yyn is the number of a rule to reduce with.  */
2921		yylen = yyr2[yyn];
2922
2923		/* If YYLEN is nonzero, implement the default value of the action:
2924	<	`$$ = $1'.
2924	>	'$$ = $1'.
2925
2926		Otherwise, the following line sets YYVAL to garbage.
2927		This behavior is undocumented and Bison
#	Line 3459 | Line 2934 | yyreduce:
2934		YY_REDUCE_PRINT (yyn);
2935		switch (yyn)
2936		{
3462	–	case 26:
3463	–
3464	–	/* Line 1455 of yacc.c  */
3465	–	#line 426 "ircd_parser.y"
3466	–	{ (yyval.number) = 0; }
3467	–	break;
3468	–
2937		case 28:
2938	<
2939	<	/* Line 1455 of yacc.c  */
2940	<	#line 428 "ircd_parser.y"
3473	<	{
3474	<	(yyval.number) = (yyvsp[(1) - (2)].number) + (yyvsp[(2) - (2)].number);
3475	<	}
3476	<	break;
3477	<
3478	<	case 29:
3479	<
3480	<	/* Line 1455 of yacc.c  */
3481	<	#line 432 "ircd_parser.y"
3482	<	{
3483	<	(yyval.number) = (yyvsp[(1) - (3)].number) + (yyvsp[(3) - (3)].number);
3484	<	}
2938	>	#line 397 "conf_parser.y"
2939	>	{ (yyval.number) = 0; }
2940	>	#line 2941 "conf_parser.c"
2941		break;
2942
2943		case 30:
2944	<
2945	<	/* Line 1455 of yacc.c  */
2946	<	#line 436 "ircd_parser.y"
3491	<	{
3492	<	(yyval.number) = (yyvsp[(1) - (3)].number) * 60 + (yyvsp[(3) - (3)].number);
3493	<	}
2944	>	#line 398 "conf_parser.y"
2945	>	{ (yyval.number) = (yyvsp[-1].number) + (yyvsp[0].number); }
2946	>	#line 2947 "conf_parser.c"
2947		break;
2948
2949		case 31:
2950	<
2951	<	/* Line 1455 of yacc.c  */
2952	<	#line 440 "ircd_parser.y"
3500	<	{
3501	<	(yyval.number) = (yyvsp[(1) - (3)].number) * 60 * 60 + (yyvsp[(3) - (3)].number);
3502	<	}
2950	>	#line 399 "conf_parser.y"
2951	>	{ (yyval.number) = (yyvsp[-2].number) + (yyvsp[0].number); }
2952	>	#line 2953 "conf_parser.c"
2953		break;
2954
2955		case 32:
2956	<
2957	<	/* Line 1455 of yacc.c  */
2958	<	#line 444 "ircd_parser.y"
3509	<	{
3510	<	(yyval.number) = (yyvsp[(1) - (3)].number) * 60 * 60 * 24 + (yyvsp[(3) - (3)].number);
3511	<	}
2956	>	#line 400 "conf_parser.y"
2957	>	{ (yyval.number) = (yyvsp[-2].number) * 60 + (yyvsp[0].number); }
2958	>	#line 2959 "conf_parser.c"
2959		break;
2960
2961		case 33:
2962	<
2963	<	/* Line 1455 of yacc.c  */
2964	<	#line 448 "ircd_parser.y"
3518	<	{
3519	<	(yyval.number) = (yyvsp[(1) - (3)].number) * 60 * 60 * 24 * 7 + (yyvsp[(3) - (3)].number);
3520	<	}
2962	>	#line 401 "conf_parser.y"
2963	>	{ (yyval.number) = (yyvsp[-2].number) * 60 * 60 + (yyvsp[0].number); }
2964	>	#line 2965 "conf_parser.c"
2965		break;
2966
2967		case 34:
2968	+	#line 402 "conf_parser.y"
2969	+	{ (yyval.number) = (yyvsp[-2].number) * 60 * 60 * 24 + (yyvsp[0].number); }
2970	+	#line 2971 "conf_parser.c"
2971	+	break;
2972
2973	<	/* Line 1455 of yacc.c  */
2974	<	#line 453 "ircd_parser.y"
2975	<	{ (yyval.number) = 0; }
2973	>	case 35:
2974	>	#line 403 "conf_parser.y"
2975	>	{ (yyval.number) = (yyvsp[-2].number) * 60 * 60 * 24 * 7 + (yyvsp[0].number); }
2976	>	#line 2977 "conf_parser.c"
2977		break;
2978
2979		case 36:
2980	<
2981	<	/* Line 1455 of yacc.c  */
2982	<	#line 454 "ircd_parser.y"
3534	<	{ (yyval.number) = (yyvsp[(1) - (2)].number) + (yyvsp[(2) - (2)].number); }
2980	>	#line 404 "conf_parser.y"
2981	>	{ (yyval.number) = (yyvsp[-2].number) * 60 * 60 * 24 * 7 * 4 + (yyvsp[0].number); }
2982	>	#line 2983 "conf_parser.c"
2983		break;
2984
2985		case 37:
2986	<
2987	<	/* Line 1455 of yacc.c  */
2988	<	#line 455 "ircd_parser.y"
3541	<	{ (yyval.number) = (yyvsp[(1) - (3)].number) + (yyvsp[(3) - (3)].number); }
2986	>	#line 405 "conf_parser.y"
2987	>	{ (yyval.number) = (yyvsp[-2].number) * 60 * 60 * 24 * 365 + (yyvsp[0].number); }
2988	>	#line 2989 "conf_parser.c"
2989		break;
2990
2991		case 38:
2992	+	#line 408 "conf_parser.y"
2993	+	{ (yyval.number) = 0; }
2994	+	#line 2995 "conf_parser.c"
2995	+	break;
2996
2997	<	/* Line 1455 of yacc.c  */
2998	<	#line 456 "ircd_parser.y"
2999	<	{ (yyval.number) = (yyvsp[(1) - (3)].number) * 1024 + (yyvsp[(3) - (3)].number); }
2997	>	case 40:
2998	>	#line 409 "conf_parser.y"
2999	>	{ (yyval.number) = (yyvsp[-1].number) + (yyvsp[0].number); }
3000	>	#line 3001 "conf_parser.c"
3001		break;
3002
3003	<	case 39:
3003	>	case 41:
3004	>	#line 410 "conf_parser.y"
3005	>	{ (yyval.number) = (yyvsp[-2].number) + (yyvsp[0].number); }
3006	>	#line 3007 "conf_parser.c"
3007	>	break;
3008
3009	<	/* Line 1455 of yacc.c  */
3010	<	#line 457 "ircd_parser.y"
3011	<	{ (yyval.number) = (yyvsp[(1) - (3)].number) * 1024 * 1024 + (yyvsp[(3) - (3)].number); }
3009	>	case 42:
3010	>	#line 411 "conf_parser.y"
3011	>	{ (yyval.number) = (yyvsp[-2].number) * 1024 + (yyvsp[0].number); }
3012	>	#line 3013 "conf_parser.c"
3013		break;
3014
3015	<	case 46:
3015	>	case 43:
3016	>	#line 412 "conf_parser.y"
3017	>	{ (yyval.number) = (yyvsp[-2].number) * 1024 * 1024 + (yyvsp[0].number); }
3018	>	#line 3019 "conf_parser.c"
3019	>	break;
3020
3021	<	/* Line 1455 of yacc.c  */
3022	<	#line 471 "ircd_parser.y"
3023	<	{
3563	<	#ifndef STATIC_MODULES /* NOOP in the static case */
3021	>	case 50:
3022	>	#line 425 "conf_parser.y"
3023	>	{
3024		if (conf_parser_ctx.pass == 2)
3025		add_conf_module(libio_basename(yylval.string));
3566	–	#endif
3026		}
3027	+	#line 3028 "conf_parser.c"
3028		break;
3029
3030	<	case 47:
3031	<
3032	<	/* Line 1455 of yacc.c  */
3573	<	#line 479 "ircd_parser.y"
3574	<	{
3575	<	#ifndef STATIC_MODULES
3030	>	case 51:
3031	>	#line 431 "conf_parser.y"
3032	>	{
3033		if (conf_parser_ctx.pass == 2)
3034		mod_add_path(yylval.string);
3578	–	#endif
3035		}
3036	+	#line 3037 "conf_parser.c"
3037		break;
3038
3039	<	case 64:
3040	<
3041	<	/* Line 1455 of yacc.c  */
3042	<	#line 501 "ircd_parser.y"
3043	<	{
3044	<	#ifdef HAVE_LIBCRYPTO
3045	<	if (conf_parser_ctx.boot && conf_parser_ctx.pass == 2)
3046	<	ServerInfo.tls_version = 0;
3590	<	#endif
3039	>	case 72:
3040	>	#line 463 "conf_parser.y"
3041	>	{
3042	>	if (conf_parser_ctx.pass == 2)
3043	>	{
3044	>	xfree(ConfigServerInfo.tls_certificate_file);
3045	>	ConfigServerInfo.tls_certificate_file = xstrdup(yylval.string);
3046	>	}
3047		}
3048	+	#line 3049 "conf_parser.c"
3049		break;
3050
3051	<	case 65:
3052	<
3053	<	/* Line 1455 of yacc.c  */
3054	<	#line 507 "ircd_parser.y"
3598	<	{
3599	<	#ifdef HAVE_LIBCRYPTO
3600	<	if (conf_parser_ctx.boot && conf_parser_ctx.pass == 2)
3051	>	case 73:
3052	>	#line 472 "conf_parser.y"
3053	>	{
3054	>	if (conf_parser_ctx.pass == 2)
3055		{
3056	<	if (!(ServerInfo.tls_version & CONF_SERVER_INFO_TLS_VERSION_SSLV3))
3057	<	SSL_CTX_set_options(ServerInfo.server_ctx, SSL_OP_NO_SSLv3);
3604	<	if (!(ServerInfo.tls_version & CONF_SERVER_INFO_TLS_VERSION_TLSV1))
3605	<	SSL_CTX_set_options(ServerInfo.server_ctx, SSL_OP_NO_TLSv1);
3056	>	xfree(ConfigServerInfo.rsa_private_key_file);
3057	>	ConfigServerInfo.rsa_private_key_file = xstrdup(yylval.string);
3058		}
3607	–	#endif
3059		}
3060	+	#line 3061 "conf_parser.c"
3061		break;
3062
3063	<	case 68:
3064	<
3065	<	/* Line 1455 of yacc.c  */
3066	<	#line 521 "ircd_parser.y"
3067	<	{
3068	<	#ifdef HAVE_LIBCRYPTO
3069	<	if (conf_parser_ctx.boot && conf_parser_ctx.pass == 2)
3070	<	ServerInfo.tls_version |= CONF_SERVER_INFO_TLS_VERSION_SSLV3;
3619	<	#endif
3063	>	case 74:
3064	>	#line 481 "conf_parser.y"
3065	>	{
3066	>	if (conf_parser_ctx.pass == 2)
3067	>	{
3068	>	xfree(ConfigServerInfo.tls_dh_param_file);
3069	>	ConfigServerInfo.tls_dh_param_file = xstrdup(yylval.string);
3070	>	}
3071		}
3072	+	#line 3073 "conf_parser.c"
3073		break;
3074
3075	<	case 69:
3076	<
3077	<	/* Line 1455 of yacc.c  */
3078	<	#line 527 "ircd_parser.y"
3079	<	{
3080	<	#ifdef HAVE_LIBCRYPTO
3081	<	if (conf_parser_ctx.boot && conf_parser_ctx.pass == 2)
3082	<	ServerInfo.tls_version |= CONF_SERVER_INFO_TLS_VERSION_TLSV1;
3631	<	#endif
3075	>	case 75:
3076	>	#line 490 "conf_parser.y"
3077	>	{
3078	>	if (conf_parser_ctx.pass == 2)
3079	>	{
3080	>	xfree(ConfigServerInfo.tls_cipher_list);
3081	>	ConfigServerInfo.tls_cipher_list = xstrdup(yylval.string);
3082	>	}
3083		}
3084	+	#line 3085 "conf_parser.c"
3085		break;
3086
3087	<	case 70:
3088	<
3089	<	/* Line 1455 of yacc.c  */
3090	<	#line 535 "ircd_parser.y"
3639	<	{
3640	<	#ifdef HAVE_LIBCRYPTO
3641	<	if (conf_parser_ctx.pass == 2 && ServerInfo.server_ctx)
3087	>	case 76:
3088	>	#line 499 "conf_parser.y"
3089	>	{
3090	>	if (conf_parser_ctx.pass == 2)
3091		{
3092	<	if (!ServerInfo.rsa_private_key_file)
3093	<	{
3645	<	yyerror("No rsa_private_key_file specified, SSL disabled");
3646	<	break;
3647	<	}
3648	<
3649	<	if (SSL_CTX_use_certificate_file(ServerInfo.server_ctx, yylval.string,
3650	<	SSL_FILETYPE_PEM) <= 0)
3651	<	{
3652	<	yyerror(ERR_lib_error_string(ERR_get_error()));
3653	<	break;
3654	<	}
3655	<
3656	<	if (SSL_CTX_use_PrivateKey_file(ServerInfo.server_ctx, ServerInfo.rsa_private_key_file,
3657	<	SSL_FILETYPE_PEM) <= 0)
3658	<	{
3659	<	yyerror(ERR_lib_error_string(ERR_get_error()));
3660	<	break;
3661	<	}
3662	<
3663	<	if (!SSL_CTX_check_private_key(ServerInfo.server_ctx))
3664	<	{
3665	<	yyerror(ERR_lib_error_string(ERR_get_error()));
3666	<	break;
3667	<	}
3092	>	xfree(ConfigServerInfo.tls_cipher_suites);
3093	>	ConfigServerInfo.tls_cipher_suites = xstrdup(yylval.string);
3094		}
3669	–	#endif
3095		}
3096	+	#line 3097 "conf_parser.c"
3097		break;
3098
3099	<	case 71:
3100	<
3101	<	/* Line 1455 of yacc.c  */
3102	<	#line 569 "ircd_parser.y"
3677	<	{
3678	<	#ifdef HAVE_LIBCRYPTO
3679	<	if (conf_parser_ctx.pass == 1)
3099	>	case 77:
3100	>	#line 508 "conf_parser.y"
3101	>	{
3102	>	if (conf_parser_ctx.pass == 2)
3103		{
3104	<	BIO *file;
3105	<
3683	<	if (ServerInfo.rsa_private_key)
3684	<	{
3685	<	RSA_free(ServerInfo.rsa_private_key);
3686	<	ServerInfo.rsa_private_key = NULL;
3687	<	}
3688	<
3689	<	if (ServerInfo.rsa_private_key_file)
3690	<	{
3691	<	MyFree(ServerInfo.rsa_private_key_file);
3692	<	ServerInfo.rsa_private_key_file = NULL;
3693	<	}
3694	<
3695	<	DupString(ServerInfo.rsa_private_key_file, yylval.string);
3696	<
3697	<	if ((file = BIO_new_file(yylval.string, "r")) == NULL)
3698	<	{
3699	<	yyerror("File open failed, ignoring");
3700	<	break;
3701	<	}
3702	<
3703	<	ServerInfo.rsa_private_key = (RSA *)PEM_read_bio_RSAPrivateKey(file, NULL,
3704	<	0, NULL);
3705	<
3706	<	BIO_set_close(file, BIO_CLOSE);
3707	<	BIO_free(file);
3708	<
3709	<	if (ServerInfo.rsa_private_key == NULL)
3710	<	{
3711	<	yyerror("Couldn't extract key, ignoring");
3712	<	break;
3713	<	}
3714	<
3715	<	if (!RSA_check_key(ServerInfo.rsa_private_key))
3716	<	{
3717	<	RSA_free(ServerInfo.rsa_private_key);
3718	<	ServerInfo.rsa_private_key = NULL;
3719	<
3720	<	yyerror("Invalid key, ignoring");
3721	<	break;
3722	<	}
3723	<
3724	<	/* require 2048 bit (256 byte) key */
3725	<	if (RSA_size(ServerInfo.rsa_private_key) != 256)
3726	<	{
3727	<	RSA_free(ServerInfo.rsa_private_key);
3728	<	ServerInfo.rsa_private_key = NULL;
3729	<
3730	<	yyerror("Not a 2048 bit key, ignoring");
3731	<	}
3104	>	xfree(ConfigServerInfo.tls_message_digest_algorithm);
3105	>	ConfigServerInfo.tls_message_digest_algorithm = xstrdup(yylval.string);
3106		}
3733	–	#endif
3107		}
3108	+	#line 3109 "conf_parser.c"
3109		break;
3110
3111	<	case 72:
3112	<
3113	<	/* Line 1455 of yacc.c  */
3740	<	#line 629 "ircd_parser.y"
3741	<	{
3742	<	/* this isn't rehashable */
3111	>	case 78:
3112	>	#line 517 "conf_parser.y"
3113	>	{
3114		if (conf_parser_ctx.pass == 2)
3115		{
3116	<	if (ServerInfo.name == NULL)
3116	>	xfree(ConfigServerInfo.tls_supported_groups);
3117	>	ConfigServerInfo.tls_supported_groups = xstrdup(yylval.string);
3118	>	}
3119	>	}
3120	>	#line 3121 "conf_parser.c"
3121	>	break;
3122	>
3123	>	case 79:
3124	>	#line 526 "conf_parser.y"
3125	>	{
3126	>	/* This isn't rehashable */
3127	>	if (conf_parser_ctx.pass == 2 && ConfigServerInfo.name == NULL)
3128	>	{
3129	>	if (server_valid_name(yylval.string) == true)
3130	>	ConfigServerInfo.name = xstrdup(yylval.string);
3131	>	else
3132		{
3133	<	/* the ircd will exit() in main() if we dont set one */
3134	<	if (strlen(yylval.string) <= HOSTLEN)
3749	<	DupString(ServerInfo.name, yylval.string);
3133	>	conf_error_report("Ignoring serverinfo::name -- invalid name. Aborting.");
3134	>	exit(EXIT_FAILURE);
3135		}
3136		}
3137		}
3138	+	#line 3139 "conf_parser.c"
3139		break;
3140
3141	<	case 73:
3142	<
3143	<	/* Line 1455 of yacc.c  */
3144	<	#line 643 "ircd_parser.y"
3145	<	{
3760	<	/* this isn't rehashable */
3761	<	if (conf_parser_ctx.pass == 2 && !ServerInfo.sid)
3141	>	case 80:
3142	>	#line 541 "conf_parser.y"
3143	>	{
3144	>	/* This isn't rehashable */
3145	>	if (conf_parser_ctx.pass == 2 && ConfigServerInfo.sid == NULL)
3146		{
3147		if (valid_sid(yylval.string))
3148	<	DupString(ServerInfo.sid, yylval.string);
3148	>	ConfigServerInfo.sid = xstrdup(yylval.string);
3149		else
3150		{
3151	<	ilog(L_ERROR, "Ignoring config file entry SID -- invalid SID. Aborting.");
3152	<	exit(0);
3151	>	conf_error_report("Ignoring serverinfo::sid -- invalid SID. Aborting.");
3152	>	exit(EXIT_FAILURE);
3153		}
3154		}
3155		}
3156	+	#line 3157 "conf_parser.c"
3157		break;
3158
3159	<	case 74:
3160	<
3161	<	/* Line 1455 of yacc.c  */
3777	<	#line 658 "ircd_parser.y"
3778	<	{
3159	>	case 81:
3160	>	#line 556 "conf_parser.y"
3161	>	{
3162		if (conf_parser_ctx.pass == 2)
3163		{
3164	<	MyFree(ServerInfo.description);
3165	<	DupString(ServerInfo.description,yylval.string);
3164	>	xfree(ConfigServerInfo.description);
3165	>	ConfigServerInfo.description = xstrdup(yylval.string);
3166	>	strlcpy(me.info, ConfigServerInfo.description, sizeof(me.info));
3167		}
3168		}
3169	+	#line 3170 "conf_parser.c"
3170		break;
3171
3172	<	case 75:
3173	<
3174	<	/* Line 1455 of yacc.c  */
3790	<	#line 667 "ircd_parser.y"
3791	<	{
3172	>	case 82:
3173	>	#line 566 "conf_parser.y"
3174	>	{
3175		if (conf_parser_ctx.pass == 2)
3176		{
3177	<	char *p;
3177	>	char *p = strchr(yylval.string, ' ');
3178
3179	<	if ((p = strchr(yylval.string, ' ')) != NULL)
3180	<	p = '\0';
3179	>	if (p)
3180	>	*p = '\0';
3181
3182	<	MyFree(ServerInfo.network_name);
3183	<	DupString(ServerInfo.network_name, yylval.string);
3182	>	xfree(ConfigServerInfo.network_name);
3183	>	ConfigServerInfo.network_name = xstrdup(yylval.string);
3184		}
3185		}
3186	+	#line 3187 "conf_parser.c"
3187		break;
3188
3189	<	case 76:
3189	>	case 83:
3190	>	#line 580 "conf_parser.y"
3191	>	{
3192	>	if (conf_parser_ctx.pass != 2)
3193	>	break;
3194
3195	<	/* Line 1455 of yacc.c  */
3196	<	#line 681 "ircd_parser.y"
3809	<	{
3810	<	if (conf_parser_ctx.pass == 2)
3811	<	{
3812	<	MyFree(ServerInfo.network_desc);
3813	<	DupString(ServerInfo.network_desc, yylval.string);
3814	<	}
3195	>	xfree(ConfigServerInfo.network_description);
3196	>	ConfigServerInfo.network_description = xstrdup(yylval.string);
3197		}
3198	+	#line 3199 "conf_parser.c"
3199		break;
3200
3201	<	case 77:
3201	>	case 84:
3202	>	#line 589 "conf_parser.y"
3203	>	{
3204	>	if (conf_parser_ctx.pass != 2)
3205	>	break;
3206
3207	<	/* Line 1455 of yacc.c  */
3821	<	#line 690 "ircd_parser.y"
3822	<	{
3823	<	if (conf_parser_ctx.pass == 2 && *yylval.string != '*')
3207	>	if ((yyvsp[-1].number) < 1)
3208		{
3209	<	struct addrinfo hints, *res;
3210	<
3211	<	memset(&hints, 0, sizeof(hints));
3212	<
3213	<	hints.ai_family   = AF_UNSPEC;
3214	<	hints.ai_socktype = SOCK_STREAM;
3831	<	hints.ai_flags    = AI_PASSIVE | AI_NUMERICHOST;
3832	<
3833	<	if (irc_getaddrinfo(yylval.string, NULL, &hints, &res))
3834	<	ilog(L_ERROR, "Invalid netmask for server vhost(%s)", yylval.string);
3835	<	else
3836	<	{
3837	<	assert(res != NULL);
3209	>	conf_error_report("default_max_clients too low, setting to 1");
3210	>	ConfigServerInfo.default_max_clients = 1;
3211	>	}
3212	>	else if ((yyvsp[-1].number) > MAXCLIENTS_MAX)
3213	>	{
3214	>	char buf[IRCD_BUFSIZE];
3215
3216	<	memcpy(&ServerInfo.ip, res->ai_addr, res->ai_addrlen);
3217	<	ServerInfo.ip.ss.ss_family = res->ai_family;
3841	<	ServerInfo.ip.ss_len = res->ai_addrlen;
3842	<	irc_freeaddrinfo(res);
3216	>	snprintf(buf, sizeof(buf), "default_max_clients too high, setting to %d", MAXCLIENTS_MAX);
3217	>	conf_error_report(buf);
3218
3219	<	ServerInfo.specific_ipv4_vhost = 1;
3845	<	}
3219	>	ConfigServerInfo.default_max_clients = MAXCLIENTS_MAX;
3220		}
3221	+	else
3222	+	ConfigServerInfo.default_max_clients = (yyvsp[-1].number);
3223		}
3224	+	#line 3225 "conf_parser.c"
3225		break;
3226
3227	<	case 78:
3227	>	case 85:
3228	>	#line 612 "conf_parser.y"
3229	>	{
3230	>	if (conf_parser_ctx.pass != 2)
3231	>	break;
3232
3233	<	/* Line 1455 of yacc.c  */
3853	<	#line 718 "ircd_parser.y"
3854	<	{
3855	<	#ifdef IPV6
3856	<	if (conf_parser_ctx.pass == 2 && *yylval.string != '*')
3233	>	if ((yyvsp[-1].number) < 9)
3234		{
3235	<	struct addrinfo hints, *res;
3236	<
3237	<	memset(&hints, 0, sizeof(hints));
3238	<
3239	<	hints.ai_family   = AF_UNSPEC;
3240	<	hints.ai_socktype = SOCK_STREAM;
3864	<	hints.ai_flags    = AI_PASSIVE | AI_NUMERICHOST;
3865	<
3866	<	if (irc_getaddrinfo(yylval.string, NULL, &hints, &res))
3867	<	ilog(L_ERROR, "Invalid netmask for server vhost6(%s)", yylval.string);
3868	<	else
3869	<	{
3870	<	assert(res != NULL);
3235	>	conf_error_report("max_nick_length too low, setting to 9");
3236	>	ConfigServerInfo.max_nick_length = 9;
3237	>	}
3238	>	else if ((yyvsp[-1].number) > NICKLEN)
3239	>	{
3240	>	char buf[IRCD_BUFSIZE];
3241
3242	<	memcpy(&ServerInfo.ip6, res->ai_addr, res->ai_addrlen);
3243	<	ServerInfo.ip6.ss.ss_family = res->ai_family;
3874	<	ServerInfo.ip6.ss_len = res->ai_addrlen;
3875	<	irc_freeaddrinfo(res);
3242	>	snprintf(buf, sizeof(buf), "max_nick_length too high, setting to %d", NICKLEN);
3243	>	conf_error_report(buf);
3244
3245	<	ServerInfo.specific_ipv6_vhost = 1;
3878	<	}
3245	>	ConfigServerInfo.max_nick_length = NICKLEN;
3246		}
3247	<	#endif
3247	>	else
3248	>	ConfigServerInfo.max_nick_length = (yyvsp[-1].number);
3249		}
3250	+	#line 3251 "conf_parser.c"
3251		break;
3252
3253	<	case 79:
3253	>	case 86:
3254	>	#line 635 "conf_parser.y"
3255	>	{
3256	>	if (conf_parser_ctx.pass != 2)
3257	>	break;
3258
3259	<	/* Line 1455 of yacc.c  */
3887	<	#line 748 "ircd_parser.y"
3888	<	{
3889	<	if (conf_parser_ctx.pass == 2)
3259	>	if ((yyvsp[-1].number) < 80)
3260		{
3261	<	recalc_fdlimit(NULL);
3262	<
3893	<	if ((yyvsp[(3) - (4)].number) < MAXCLIENTS_MIN)
3894	<	{
3895	<	char buf[IRCD_BUFSIZE];
3896	<	ircsprintf(buf, "MAXCLIENTS too low, setting to %d", MAXCLIENTS_MIN);
3897	<	yyerror(buf);
3898	<	}
3899	<	else if ((yyvsp[(3) - (4)].number) > MAXCLIENTS_MAX)
3900	<	{
3901	<	char buf[IRCD_BUFSIZE];
3902	<	ircsprintf(buf, "MAXCLIENTS too high, setting to %d", MAXCLIENTS_MAX);
3903	<	yyerror(buf);
3904	<	}
3905	<	else
3906	<	ServerInfo.max_clients = (yyvsp[(3) - (4)].number);
3261	>	conf_error_report("max_topic_length too low, setting to 80");
3262	>	ConfigServerInfo.max_topic_length = 80;
3263		}
3264	<	}
3909	<	break;
3910	<
3911	<	case 80:
3912	<
3913	<	/* Line 1455 of yacc.c  */
3914	<	#line 771 "ircd_parser.y"
3915	<	{
3916	<	if (conf_parser_ctx.pass == 2)
3264	>	else if ((yyvsp[-1].number) > TOPICLEN)
3265		{
3266	<	if (yylval.number)
3919	<	{
3920	<	ServerInfo.hub = 1;
3921	<	delete_capability("HUB");
3922	<	add_capability("HUB", CAP_HUB, 1);
3923	<	}
3924	<	else if (ServerInfo.hub)
3925	<	{
3266	>	char buf[IRCD_BUFSIZE];
3267
3268	<	ServerInfo.hub = 0;
3269	<	delete_capability("HUB");
3270	<	}
3268	>	snprintf(buf, sizeof(buf), "max_topic_length too high, setting to %d", TOPICLEN);
3269	>	conf_error_report(buf);
3270	>
3271	>	ConfigServerInfo.max_topic_length = TOPICLEN;
3272		}
3273	+	else
3274	+	ConfigServerInfo.max_topic_length = (yyvsp[-1].number);
3275		}
3276	+	#line 3277 "conf_parser.c"
3277		break;
3278
3279	<	case 88:
3280	<
3281	<	/* Line 1455 of yacc.c  */
3937	<	#line 799 "ircd_parser.y"
3938	<	{
3279	>	case 87:
3280	>	#line 658 "conf_parser.y"
3281	>	{
3282		if (conf_parser_ctx.pass == 2)
3283	<	{
3941	<	MyFree(AdminInfo.name);
3942	<	DupString(AdminInfo.name, yylval.string);
3943	<	}
3283	>	ConfigServerInfo.hub = yylval.number;
3284		}
3285	+	#line 3286 "conf_parser.c"
3286		break;
3287
3288	<	case 89:
3288	>	case 95:
3289	>	#line 676 "conf_parser.y"
3290	>	{
3291	>	if (conf_parser_ctx.pass != 2)
3292	>	break;
3293
3294	<	/* Line 1455 of yacc.c  */
3295	<	#line 808 "ircd_parser.y"
3951	<	{
3952	<	if (conf_parser_ctx.pass == 2)
3953	<	{
3954	<	MyFree(AdminInfo.email);
3955	<	DupString(AdminInfo.email, yylval.string);
3956	<	}
3294	>	xfree(ConfigAdminInfo.name);
3295	>	ConfigAdminInfo.name = xstrdup(yylval.string);
3296		}
3297	+	#line 3298 "conf_parser.c"
3298		break;
3299
3300	<	case 90:
3300	>	case 96:
3301	>	#line 685 "conf_parser.y"
3302	>	{
3303	>	if (conf_parser_ctx.pass != 2)
3304	>	break;
3305
3306	<	/* Line 1455 of yacc.c  */
3307	<	#line 817 "ircd_parser.y"
3964	<	{
3965	<	if (conf_parser_ctx.pass == 2)
3966	<	{
3967	<	MyFree(AdminInfo.description);
3968	<	DupString(AdminInfo.description, yylval.string);
3969	<	}
3306	>	xfree(ConfigAdminInfo.email);
3307	>	ConfigAdminInfo.email = xstrdup(yylval.string);
3308		}
3309	+	#line 3310 "conf_parser.c"
3310		break;
3311
3312	<	case 107:
3313	<
3314	<	/* Line 1455 of yacc.c  */
3315	<	#line 844 "ircd_parser.y"
3977	<	{
3978	<	}
3312	>	case 97:
3313	>	#line 694 "conf_parser.y"
3314	>	{
3315	>	if (conf_parser_ctx.pass != 2)
3316		break;
3317
3318	<	case 108:
3319	<
3320	<	/* Line 1455 of yacc.c  */
3321	<	#line 848 "ircd_parser.y"
3985	<	{
3986	<	}
3318	>	xfree(ConfigAdminInfo.description);
3319	>	ConfigAdminInfo.description = xstrdup(yylval.string);
3320	>	}
3321	>	#line 3322 "conf_parser.c"
3322		break;
3323
3324	<	case 109:
3325	<
3326	<	/* Line 1455 of yacc.c  */
3992	<	#line 852 "ircd_parser.y"
3993	<	{
3324	>	case 98:
3325	>	#line 707 "conf_parser.y"
3326	>	{
3327		if (conf_parser_ctx.pass == 2)
3328	<	strlcpy(ConfigLoggingEntry.userlog, yylval.string,
3996	<	sizeof(ConfigLoggingEntry.userlog));
3328	>	reset_block_state();
3329		}
3330	+	#line 3331 "conf_parser.c"
3331		break;
3332
3333	<	case 110:
3333	>	case 99:
3334	>	#line 711 "conf_parser.y"
3335	>	{
3336	>	dlink_node *node;
3337
3338	<	/* Line 1455 of yacc.c  */
4003	<	#line 859 "ircd_parser.y"
4004	<	{
4005	<	if (conf_parser_ctx.pass == 2)
4006	<	strlcpy(ConfigLoggingEntry.failed_operlog, yylval.string,
4007	<	sizeof(ConfigLoggingEntry.failed_operlog));
4008	<	}
3338	>	if (conf_parser_ctx.pass != 2)
3339		break;
3340
3341	<	case 111:
3341	>	if (!block_state.file.buf[0])
3342	>	break;
3343
3344	<	/* Line 1455 of yacc.c  */
3345	<	#line 866 "ircd_parser.y"
4015	<	{
4016	<	if (conf_parser_ctx.pass == 2)
4017	<	strlcpy(ConfigLoggingEntry.operlog, yylval.string,
4018	<	sizeof(ConfigLoggingEntry.operlog));
3344	>	DLINK_FOREACH(node, block_state.mask.list.head)
3345	>	motd_add(node->data, block_state.file.buf);
3346		}
3347	+	#line 3348 "conf_parser.c"
3348		break;
3349
3350	<	case 112:
3351	<
3352	<	/* Line 1455 of yacc.c  */
4025	<	#line 873 "ircd_parser.y"
4026	<	{
3350	>	case 105:
3351	>	#line 728 "conf_parser.y"
3352	>	{
3353		if (conf_parser_ctx.pass == 2)
3354	<	strlcpy(ConfigLoggingEntry.operspylog, yylval.string,
4029	<	sizeof(ConfigLoggingEntry.operspylog));
3354	>	dlinkAdd(xstrdup(yylval.string), make_dlink_node(), &block_state.mask.list);
3355		}
3356	+	#line 3357 "conf_parser.c"
3357		break;
3358
3359	<	case 113:
3360	<
3361	<	/* Line 1455 of yacc.c  */
4036	<	#line 880 "ircd_parser.y"
4037	<	{
3359	>	case 106:
3360	>	#line 734 "conf_parser.y"
3361	>	{
3362		if (conf_parser_ctx.pass == 2)
3363	<	strlcpy(ConfigLoggingEntry.glinelog, yylval.string,
4040	<	sizeof(ConfigLoggingEntry.glinelog));
3363	>	strlcpy(block_state.file.buf, yylval.string, sizeof(block_state.file.buf));
3364		}
3365	+	#line 3366 "conf_parser.c"
3366		break;
3367
3368	<	case 114:
3369	<
3370	<	/* Line 1455 of yacc.c  */
4047	<	#line 887 "ircd_parser.y"
4048	<	{
3368	>	case 107:
3369	>	#line 744 "conf_parser.y"
3370	>	{
3371		if (conf_parser_ctx.pass == 2)
3372	<	strlcpy(ConfigLoggingEntry.klinelog, yylval.string,
4051	<	sizeof(ConfigLoggingEntry.klinelog));
3372	>	reset_block_state();
3373		}
3374	+	#line 3375 "conf_parser.c"
3375		break;
3376
3377	<	case 115:
3377	>	case 108:
3378	>	#line 748 "conf_parser.y"
3379	>	{
3380	>	if (conf_parser_ctx.pass != 2)
3381	>	break;
3382
3383	<	/* Line 1455 of yacc.c  */
3384	<	#line 894 "ircd_parser.y"
3385	<	{
3386	<	if (conf_parser_ctx.pass == 2)
3387	<	strlcpy(ConfigLoggingEntry.ioerrlog, yylval.string,
3388	<	sizeof(ConfigLoggingEntry.ioerrlog));
3383	>	if (!block_state.command.buf[0] ||
3384	>	!block_state.name.buf[0] ||
3385	>	!block_state.nick.buf[0] ||
3386	>	!block_state.host.buf[0])
3387	>	break;
3388	>
3389	>	pseudo_register(block_state.name.buf, block_state.nick.buf, block_state.host.buf,
3390	>	block_state.prepend.buf, block_state.command.buf);
3391		}
3392	+	#line 3393 "conf_parser.c"
3393		break;
3394
3395		case 116:
3396	<
3397	<	/* Line 1455 of yacc.c  */
4069	<	#line 901 "ircd_parser.y"
4070	<	{
3396	>	#line 766 "conf_parser.y"
3397	>	{
3398		if (conf_parser_ctx.pass == 2)
3399	<	strlcpy(ConfigLoggingEntry.killlog, yylval.string,
4073	<	sizeof(ConfigLoggingEntry.killlog));
3399	>	strlcpy(block_state.command.buf, yylval.string, sizeof(block_state.command.buf));
3400		}
3401	+	#line 3402 "conf_parser.c"
3402		break;
3403
3404		case 117:
3405	<
3406	<	/* Line 1455 of yacc.c  */
4080	<	#line 908 "ircd_parser.y"
4081	<	{
3405	>	#line 772 "conf_parser.y"
3406	>	{
3407		if (conf_parser_ctx.pass == 2)
3408	<	set_log_level(L_CRIT);
3408	>	strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
3409		}
3410	+	#line 3411 "conf_parser.c"
3411		break;
3412
3413		case 118:
3414	<
3415	<	/* Line 1455 of yacc.c  */
4090	<	#line 912 "ircd_parser.y"
4091	<	{
3414	>	#line 778 "conf_parser.y"
3415	>	{
3416		if (conf_parser_ctx.pass == 2)
3417	<	set_log_level(L_ERROR);
3417	>	strlcpy(block_state.prepend.buf, yylval.string, sizeof(block_state.prepend.buf));
3418		}
3419	+	#line 3420 "conf_parser.c"
3420		break;
3421
3422		case 119:
3423	<
3424	<	/* Line 1455 of yacc.c  */
4100	<	#line 916 "ircd_parser.y"
4101	<	{
3423	>	#line 784 "conf_parser.y"
3424	>	{
3425		if (conf_parser_ctx.pass == 2)
3426	<	set_log_level(L_WARN);
3426	>	{
3427	>	struct split_nuh_item nuh;
3428	>
3429	>	nuh.nuhmask  = yylval.string;
3430	>	nuh.nickptr  = NULL;
3431	>	nuh.userptr  = block_state.nick.buf;
3432	>	nuh.hostptr  = block_state.host.buf;
3433	>	nuh.nicksize = 0;
3434	>	nuh.usersize = sizeof(block_state.nick.buf);
3435	>	nuh.hostsize = sizeof(block_state.host.buf);
3436	>
3437	>	split_nuh(&nuh);
3438	>	}
3439		}
3440	+	#line 3441 "conf_parser.c"
3441		break;
3442
3443	<	case 120:
3444	<
3445	<	/* Line 1455 of yacc.c  */
4110	<	#line 920 "ircd_parser.y"
4111	<	{
3443	>	case 126:
3444	>	#line 812 "conf_parser.y"
3445	>	{
3446		if (conf_parser_ctx.pass == 2)
3447	<	set_log_level(L_NOTICE);
3447	>	ConfigLog.use_logging = yylval.number;
3448		}
3449	+	#line 3450 "conf_parser.c"
3450		break;
3451
3452	<	case 121:
3453	<
3454	<	/* Line 1455 of yacc.c  */
4120	<	#line 924 "ircd_parser.y"
4121	<	{
3452	>	case 127:
3453	>	#line 818 "conf_parser.y"
3454	>	{
3455		if (conf_parser_ctx.pass == 2)
3456	<	set_log_level(L_TRACE);
3456	>	reset_block_state();
3457		}
3458	+	#line 3459 "conf_parser.c"
3459		break;
3460
3461	<	case 122:
3461	>	case 128:
3462	>	#line 822 "conf_parser.y"
3463	>	{
3464	>	if (conf_parser_ctx.pass != 2)
3465	>	break;
3466
3467	<	/* Line 1455 of yacc.c  */
3468	<	#line 928 "ircd_parser.y"
3469	<	{
4132	<	if (conf_parser_ctx.pass == 2)
4133	<	set_log_level(L_INFO);
3467	>	if (block_state.type.value && block_state.file.buf[0])
3468	>	log_set_file(block_state.type.value, block_state.size.value,
3469	>	block_state.file.buf);
3470		}
3471	+	#line 3472 "conf_parser.c"
3472		break;
3473
3474	<	case 123:
3474	>	case 135:
3475	>	#line 838 "conf_parser.y"
3476	>	{
3477	>	if (conf_parser_ctx.pass != 2)
3478	>	break;
3479
3480	<	/* Line 1455 of yacc.c  */
4140	<	#line 932 "ircd_parser.y"
4141	<	{
4142	<	if (conf_parser_ctx.pass == 2)
4143	<	set_log_level(L_DEBUG);
3480	>	strlcpy(block_state.file.buf, yylval.string, sizeof(block_state.file.buf));
3481		}
3482	+	#line 3483 "conf_parser.c"
3483		break;
3484
3485	<	case 124:
3486	<
3487	<	/* Line 1455 of yacc.c  */
3488	<	#line 938 "ircd_parser.y"
4151	<	{
4152	<	if (conf_parser_ctx.pass == 2)
4153	<	ConfigLoggingEntry.use_logging = yylval.number;
3485	>	case 136:
3486	>	#line 846 "conf_parser.y"
3487	>	{
3488	>	block_state.size.value = (yyvsp[-1].number);
3489		}
3490	+	#line 3491 "conf_parser.c"
3491		break;
3492
3493	<	case 125:
3493	>	case 137:
3494	>	#line 849 "conf_parser.y"
3495	>	{
3496	>	block_state.size.value = 0;
3497	>	}
3498	>	#line 3499 "conf_parser.c"
3499	>	break;
3500
3501	<	/* Line 1455 of yacc.c  */
3502	<	#line 947 "ircd_parser.y"
3503	<	{
3501	>	case 138:
3502	>	#line 854 "conf_parser.y"
3503	>	{
3504		if (conf_parser_ctx.pass == 2)
3505	<	{
4164	<	yy_conf = make_conf_item(OPER_TYPE);
4165	<	yy_aconf = map_to_conf(yy_conf);
4166	<	SetConfEncrypted(yy_aconf); /* Yes, the default is encrypted */
4167	<	}
4168	<	else
4169	<	{
4170	<	MyFree(class_name);
4171	<	class_name = NULL;
4172	<	}
3505	>	block_state.type.value = 0;
3506		}
3507	+	#line 3508 "conf_parser.c"
3508		break;
3509
3510	<	case 126:
3511	<
3512	<	/* Line 1455 of yacc.c  */
4179	<	#line 960 "ircd_parser.y"
4180	<	{
3510	>	case 142:
3511	>	#line 861 "conf_parser.y"
3512	>	{
3513		if (conf_parser_ctx.pass == 2)
3514	<	{
4183	<	struct CollectItem *yy_tmp;
4184	<	dlink_node *ptr;
4185	<	dlink_node *next_ptr;
4186	<
4187	<	conf_add_class_to_conf(yy_conf, class_name);
4188	<
4189	<	/* Now, make sure there is a copy of the "base" given oper
4190	<	* block in each of the collected copies
4191	<	*/
4192	<
4193	<	DLINK_FOREACH_SAFE(ptr, next_ptr, col_conf_list.head)
4194	<	{
4195	<	struct AccessItem *new_aconf;
4196	<	struct ConfItem *new_conf;
4197	<	yy_tmp = ptr->data;
4198	<
4199	<	new_conf = make_conf_item(OPER_TYPE);
4200	<	new_aconf = (struct AccessItem *)map_to_conf(new_conf);
4201	<
4202	<	new_aconf->flags = yy_aconf->flags;
4203	<
4204	<	if (yy_conf->name != NULL)
4205	<	DupString(new_conf->name, yy_conf->name);
4206	<	if (yy_tmp->user != NULL)
4207	<	DupString(new_aconf->user, yy_tmp->user);
4208	<	else
4209	<	DupString(new_aconf->user, "*");
4210	<	if (yy_tmp->host != NULL)
4211	<	DupString(new_aconf->host, yy_tmp->host);
4212	<	else
4213	<	DupString(new_aconf->host, "*");
4214	<	conf_add_class_to_conf(new_conf, class_name);
4215	<	if (yy_aconf->passwd != NULL)
4216	<	DupString(new_aconf->passwd, yy_aconf->passwd);
4217	<
4218	<	new_aconf->port = yy_aconf->port;
4219	<	#ifdef HAVE_LIBCRYPTO
4220	<	if (yy_aconf->rsa_public_key_file != NULL)
4221	<	{
4222	<	BIO *file;
4223	<
4224	<	DupString(new_aconf->rsa_public_key_file,
4225	<	yy_aconf->rsa_public_key_file);
4226	<
4227	<	file = BIO_new_file(yy_aconf->rsa_public_key_file, "r");
4228	<	new_aconf->rsa_public_key = (RSA *)PEM_read_bio_RSA_PUBKEY(file,
4229	<	NULL, 0, NULL);
4230	<	BIO_set_close(file, BIO_CLOSE);
4231	<	BIO_free(file);
4232	<	}
4233	<	#endif
4234	<
4235	<	#ifdef HAVE_LIBCRYPTO
4236	<	if (yy_tmp->name && (yy_tmp->passwd || yy_aconf->rsa_public_key)
4237	<	&& yy_tmp->host)
4238	<	#else
4239	<	if (yy_tmp->name && yy_tmp->passwd && yy_tmp->host)
4240	<	#endif
4241	<	{
4242	<	conf_add_class_to_conf(new_conf, class_name);
4243	<	if (yy_tmp->name != NULL)
4244	<	DupString(new_conf->name, yy_tmp->name);
4245	<	}
4246	<
4247	<	dlinkDelete(&yy_tmp->node, &col_conf_list);
4248	<	free_collect_item(yy_tmp);
4249	<	}
4250	<
4251	<	yy_conf = NULL;
4252	<	yy_aconf = NULL;
4253	<
4254	<
4255	<	MyFree(class_name);
4256	<	class_name = NULL;
4257	<	}
3514	>	block_state.type.value = LOG_TYPE_USER;
3515		}
3516	+	#line 3517 "conf_parser.c"
3517		break;
3518
3519	<	case 154:
3520	<
3521	<	/* Line 1455 of yacc.c  */
4264	<	#line 1052 "ircd_parser.y"
4265	<	{
3519	>	case 143:
3520	>	#line 865 "conf_parser.y"
3521	>	{
3522		if (conf_parser_ctx.pass == 2)
3523	<	{
4268	<	if (strlen(yylval.string) > OPERNICKLEN)
4269	<	yylval.string[OPERNICKLEN] = '\0';
4270	<
4271	<	MyFree(yy_conf->name);
4272	<	DupString(yy_conf->name, yylval.string);
4273	<	}
3523	>	block_state.type.value = LOG_TYPE_OPER;
3524		}
3525	+	#line 3526 "conf_parser.c"
3526		break;
3527
3528	<	case 155:
3529	<
3530	<	/* Line 1455 of yacc.c  */
4280	<	#line 1064 "ircd_parser.y"
4281	<	{
3528	>	case 144:
3529	>	#line 869 "conf_parser.y"
3530	>	{
3531		if (conf_parser_ctx.pass == 2)
3532	<	{
4284	<	if (strlen(yylval.string) > OPERNICKLEN)
4285	<	yylval.string[OPERNICKLEN] = '\0';
4286	<
4287	<	MyFree(yy_conf->name);
4288	<	DupString(yy_conf->name, yylval.string);
4289	<	}
3532	>	block_state.type.value = LOG_TYPE_XLINE;
3533		}
3534	+	#line 3535 "conf_parser.c"
3535		break;
3536
3537	<	case 156:
3538	<
3539	<	/* Line 1455 of yacc.c  */
4296	<	#line 1076 "ircd_parser.y"
4297	<	{
3537	>	case 145:
3538	>	#line 873 "conf_parser.y"
3539	>	{
3540		if (conf_parser_ctx.pass == 2)
3541	<	{
3542	<	struct split_nuh_item nuh;
3543	<
3544	<	nuh.nuhmask  = yylval.string;
4303	<	nuh.nickptr  = NULL;
4304	<	nuh.userptr  = userbuf;
4305	<	nuh.hostptr  = hostbuf;
4306	<
4307	<	nuh.nicksize = 0;
4308	<	nuh.usersize = sizeof(userbuf);
4309	<	nuh.hostsize = sizeof(hostbuf);
4310	<
4311	<	split_nuh(&nuh);
4312	<
4313	<	if (yy_aconf->user == NULL)
4314	<	{
4315	<	DupString(yy_aconf->user, userbuf);
4316	<	DupString(yy_aconf->host, hostbuf);
4317	<	}
4318	<	else
4319	<	{
4320	<	struct CollectItem *yy_tmp = MyMalloc(sizeof(struct CollectItem));
4321	<
4322	<	DupString(yy_tmp->user, userbuf);
4323	<	DupString(yy_tmp->host, hostbuf);
3541	>	block_state.type.value = LOG_TYPE_RESV;
3542	>	}
3543	>	#line 3544 "conf_parser.c"
3544	>	break;
3545
3546	<	dlinkAdd(yy_tmp, &yy_tmp->node, &col_conf_list);
3547	<	}
3548	<	}
3546	>	case 146:
3547	>	#line 877 "conf_parser.y"
3548	>	{
3549	>	if (conf_parser_ctx.pass == 2)
3550	>	block_state.type.value = LOG_TYPE_DLINE;
3551		}
3552	+	#line 3553 "conf_parser.c"
3553		break;
3554
3555	<	case 157:
3555	>	case 147:
3556	>	#line 881 "conf_parser.y"
3557	>	{
3558	>	if (conf_parser_ctx.pass == 2)
3559	>	block_state.type.value = LOG_TYPE_KLINE;
3560	>	}
3561	>	#line 3562 "conf_parser.c"
3562	>	break;
3563
3564	<	/* Line 1455 of yacc.c  */
3565	<	#line 1110 "ircd_parser.y"
3566	<	{
3564	>	case 148:
3565	>	#line 885 "conf_parser.y"
3566	>	{
3567		if (conf_parser_ctx.pass == 2)
3568	<	{
3569	<	if (yy_aconf->passwd != NULL)
3570	<	memset(yy_aconf->passwd, 0, strlen(yy_aconf->passwd));
3568	>	block_state.type.value = LOG_TYPE_KILL;
3569	>	}
3570	>	#line 3571 "conf_parser.c"
3571	>	break;
3572
3573	<	MyFree(yy_aconf->passwd);
3574	<	DupString(yy_aconf->passwd, yylval.string);
3575	<	}
3573	>	case 149:
3574	>	#line 889 "conf_parser.y"
3575	>	{
3576	>	if (conf_parser_ctx.pass == 2)
3577	>	block_state.type.value = LOG_TYPE_DEBUG;
3578		}
3579	+	#line 3580 "conf_parser.c"
3580		break;
3581
3582	<	case 158:
3582	>	case 150:
3583	>	#line 899 "conf_parser.y"
3584	>	{
3585	>	if (conf_parser_ctx.pass != 2)
3586	>	break;
3587
3588	<	/* Line 1455 of yacc.c  */
3589	<	#line 1122 "ircd_parser.y"
4351	<	{
4352	<	if (conf_parser_ctx.pass == 2)
4353	<	{
4354	<	if (yylval.number)
4355	<	SetConfEncrypted(yy_aconf);
4356	<	else
4357	<	ClearConfEncrypted(yy_aconf);
4358	<	}
3588	>	reset_block_state();
3589	>	block_state.flags.value |= CONF_FLAGS_ENCRYPTED;
3590		}
3591	+	#line 3592 "conf_parser.c"
3592		break;
3593
3594	<	case 159:
3594	>	case 151:
3595	>	#line 906 "conf_parser.y"
3596	>	{
3597	>	dlink_node *node;
3598
3599	<	/* Line 1455 of yacc.c  */
3600	<	#line 1133 "ircd_parser.y"
4366	<	{
4367	<	#ifdef HAVE_LIBCRYPTO
4368	<	if (conf_parser_ctx.pass == 2)
4369	<	{
4370	<	BIO *file;
3599	>	if (conf_parser_ctx.pass != 2)
3600	>	break;
3601
3602	<	if (yy_aconf->rsa_public_key != NULL)
3603	<	{
4374	<	RSA_free(yy_aconf->rsa_public_key);
4375	<	yy_aconf->rsa_public_key = NULL;
4376	<	}
3602	>	if (!block_state.name.buf[0])
3603	>	break;
3604
3605	<	if (yy_aconf->rsa_public_key_file != NULL)
3606	<	{
4380	<	MyFree(yy_aconf->rsa_public_key_file);
4381	<	yy_aconf->rsa_public_key_file = NULL;
4382	<	}
3605	>	if (!block_state.rpass.buf[0])
3606	>	break;
3607
3608	<	DupString(yy_aconf->rsa_public_key_file, yylval.string);
3609	<	file = BIO_new_file(yylval.string, "r");
3608	>	DLINK_FOREACH(node, block_state.mask.list.head)
3609	>	{
3610	>	struct split_nuh_item nuh;
3611	>	char *s = node->data;
3612
3613	<	if (file == NULL)
3614	<	{
4389	<	yyerror("Ignoring rsa_public_key_file -- file doesn't exist");
4390	<	break;
4391	<	}
3613	>	if (EmptyString(s))
3614	>	continue;
3615
3616	<	yy_aconf->rsa_public_key = (RSA *)PEM_read_bio_RSA_PUBKEY(file, NULL, 0, NULL);
3616	>	nuh.nuhmask  = s;
3617	>	nuh.nickptr  = NULL;
3618	>	nuh.userptr  = block_state.user.buf;
3619	>	nuh.hostptr  = block_state.host.buf;
3620
3621	<	if (yy_aconf->rsa_public_key == NULL)
3622	<	{
3623	<	yyerror("Ignoring rsa_public_key_file -- Key invalid; check key syntax.");
4398	<	break;
4399	<	}
3621	>	nuh.nicksize = 0;
3622	>	nuh.usersize = sizeof(block_state.user.buf);
3623	>	nuh.hostsize = sizeof(block_state.host.buf);
3624
3625	<	BIO_set_close(file, BIO_CLOSE);
4402	<	BIO_free(file);
4403	<	}
4404	<	#endif /* HAVE_LIBCRYPTO */
4405	<	}
4406	<	break;
3625	>	split_nuh(&nuh);
3626
3627	<	case 160:
3627	>	struct MaskItem *conf = conf_make(CONF_OPER);
3628	>	conf->addr = xcalloc(sizeof(*conf->addr));
3629	>	conf->name = xstrdup(block_state.name.buf);
3630	>	conf->user = xstrdup(block_state.user.buf);
3631	>	conf->host = xstrdup(block_state.host.buf);
3632
3633	<	/* Line 1455 of yacc.c  */
3634	<	#line 1175 "ircd_parser.y"
4412	<	{
4413	<	if (conf_parser_ctx.pass == 2)
4414	<	{
4415	<	MyFree(class_name);
4416	<	DupString(class_name, yylval.string);
4417	<	}
4418	<	}
4419	<	break;
3633	>	if (block_state.cert.buf[0])
3634	>	conf->certfp = xstrdup(block_state.cert.buf);
3635
3636	<	case 161:
3636	>	if (block_state.rpass.buf[0])
3637	>	conf->passwd = xstrdup(block_state.rpass.buf);
3638
3639	<	/* Line 1455 of yacc.c  */
3640	<	#line 1184 "ircd_parser.y"
3641	<	{
3642	<	if (conf_parser_ctx.pass == 2)
3643	<	yy_aconf->modes = 0;
3639	>	if (block_state.whois.buf[0])
3640	>	conf->whois = xstrdup(block_state.whois.buf);
3641	>
3642	>	conf->flags = block_state.flags.value;
3643	>	conf->modes = block_state.modes.value;
3644	>	conf->port  = block_state.port.value;
3645	>	conf->htype = parse_netmask(conf->host, conf->addr, &conf->bits);
3646	>
3647	>	conf_add_class_to_conf(conf, block_state.class.buf);
3648	>	}
3649		}
3650	+	#line 3651 "conf_parser.c"
3651		break;
3652
3653		case 165:
3654	<
3655	<	/* Line 1455 of yacc.c  */
4434	<	#line 1191 "ircd_parser.y"
4435	<	{
3654	>	#line 975 "conf_parser.y"
3655	>	{
3656		if (conf_parser_ctx.pass == 2)
3657	<	yy_aconf->modes |= UMODE_BOTS;
3657	>	strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
3658		}
3659	+	#line 3660 "conf_parser.c"
3660		break;
3661
3662		case 166:
3663	<
3664	<	/* Line 1455 of yacc.c  */
4444	<	#line 1195 "ircd_parser.y"
4445	<	{
3663	>	#line 981 "conf_parser.y"
3664	>	{
3665		if (conf_parser_ctx.pass == 2)
3666	<	yy_aconf->modes |= UMODE_CCONN;
3666	>	dlinkAdd(xstrdup(yylval.string), make_dlink_node(), &block_state.mask.list);
3667		}
3668	+	#line 3669 "conf_parser.c"
3669		break;
3670
3671		case 167:
3672	<
3673	<	/* Line 1455 of yacc.c  */
4454	<	#line 1199 "ircd_parser.y"
4455	<	{
3672	>	#line 987 "conf_parser.y"
3673	>	{
3674		if (conf_parser_ctx.pass == 2)
3675	<	yy_aconf->modes |= UMODE_CCONN_FULL;
3675	>	strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
3676		}
3677	+	#line 3678 "conf_parser.c"
3678		break;
3679
3680		case 168:
3681	<
3682	<	/* Line 1455 of yacc.c  */
4464	<	#line 1203 "ircd_parser.y"
4465	<	{
3681	>	#line 993 "conf_parser.y"
3682	>	{
3683		if (conf_parser_ctx.pass == 2)
3684	<	yy_aconf->modes |= UMODE_DEAF;
3684	>	strlcpy(block_state.whois.buf, yylval.string, sizeof(block_state.whois.buf));
3685		}
3686	+	#line 3687 "conf_parser.c"
3687		break;
3688
3689		case 169:
3690	+	#line 999 "conf_parser.y"
3691	+	{
3692	+	if (conf_parser_ctx.pass != 2)
3693	+	break;
3694
3695	<	/* Line 1455 of yacc.c  */
3696	<	#line 1207 "ircd_parser.y"
3697	<	{
3698	<	if (conf_parser_ctx.pass == 2)
4477	<	yy_aconf->modes |= UMODE_DEBUG;
3695	>	if (yylval.number)
3696	>	block_state.flags.value |= CONF_FLAGS_ENCRYPTED;
3697	>	else
3698	>	block_state.flags.value &= ~CONF_FLAGS_ENCRYPTED;
3699		}
3700	+	#line 3701 "conf_parser.c"
3701		break;
3702
3703		case 170:
3704	<
3705	<	/* Line 1455 of yacc.c  */
4484	<	#line 1211 "ircd_parser.y"
4485	<	{
3704	>	#line 1010 "conf_parser.y"
3705	>	{
3706		if (conf_parser_ctx.pass == 2)
3707	<	yy_aconf->modes |= UMODE_FULL;
3707	>	strlcpy(block_state.cert.buf, yylval.string, sizeof(block_state.cert.buf));
3708		}
3709	+	#line 3710 "conf_parser.c"
3710		break;
3711
3712		case 171:
3713	+	#line 1016 "conf_parser.y"
3714	+	{
3715	+	if (conf_parser_ctx.pass != 2)
3716	+	break;
3717
3718	<	/* Line 1455 of yacc.c  */
3719	<	#line 1215 "ircd_parser.y"
3720	<	{
3721	<	if (conf_parser_ctx.pass == 2)
4497	<	yy_aconf->modes |= UMODE_SKILL;
3718	>	if (yylval.number)
3719	>	block_state.flags.value |= CONF_FLAGS_TLS;
3720	>	else
3721	>	block_state.flags.value &= ~CONF_FLAGS_TLS;
3722		}
3723	+	#line 3724 "conf_parser.c"
3724		break;
3725
3726		case 172:
3727	<
3728	<	/* Line 1455 of yacc.c  */
4504	<	#line 1219 "ircd_parser.y"
4505	<	{
3727	>	#line 1027 "conf_parser.y"
3728	>	{
3729		if (conf_parser_ctx.pass == 2)
3730	<	yy_aconf->modes |= UMODE_NCHANGE;
3730	>	strlcpy(block_state.class.buf, yylval.string, sizeof(block_state.class.buf));
3731		}
3732	+	#line 3733 "conf_parser.c"
3733		break;
3734
3735		case 173:
3736	<
3737	<	/* Line 1455 of yacc.c  */
4514	<	#line 1223 "ircd_parser.y"
4515	<	{
4516	<	if (conf_parser_ctx.pass == 2)
4517	<	yy_aconf->modes |= UMODE_REJ;
4518	<	}
4519	<	break;
4520	<
4521	<	case 174:
4522	<
4523	<	/* Line 1455 of yacc.c  */
4524	<	#line 1227 "ircd_parser.y"
4525	<	{
4526	<	if (conf_parser_ctx.pass == 2)
4527	<	yy_aconf->modes |= UMODE_UNAUTH;
4528	<	}
4529	<	break;
4530	<
4531	<	case 175:
4532	<
4533	<	/* Line 1455 of yacc.c  */
4534	<	#line 1231 "ircd_parser.y"
4535	<	{
4536	<	if (conf_parser_ctx.pass == 2)
4537	<	yy_aconf->modes |= UMODE_SPY;
4538	<	}
4539	<	break;
4540	<
4541	<	case 176:
4542	<
4543	<	/* Line 1455 of yacc.c  */
4544	<	#line 1235 "ircd_parser.y"
4545	<	{
3736	>	#line 1033 "conf_parser.y"
3737	>	{
3738		if (conf_parser_ctx.pass == 2)
3739	<	yy_aconf->modes |= UMODE_EXTERNAL;
3739	>	block_state.modes.value = 0;
3740		}
3741	+	#line 3742 "conf_parser.c"
3742		break;
3743
3744		case 177:
3745	<
3746	<	/* Line 1455 of yacc.c  */
4554	<	#line 1239 "ircd_parser.y"
4555	<	{
3745	>	#line 1040 "conf_parser.y"
3746	>	{
3747		if (conf_parser_ctx.pass == 2)
3748	<	yy_aconf->modes |= UMODE_OPERWALL;
3748	>	block_state.modes.value |= UMODE_BOT;
3749		}
3750	+	#line 3751 "conf_parser.c"
3751		break;
3752
3753		case 178:
3754	<
3755	<	/* Line 1455 of yacc.c  */
4564	<	#line 1243 "ircd_parser.y"
4565	<	{
3754	>	#line 1044 "conf_parser.y"
3755	>	{
3756		if (conf_parser_ctx.pass == 2)
3757	<	yy_aconf->modes |= UMODE_SERVNOTICE;
3757	>	block_state.modes.value |= UMODE_CCONN;
3758		}
3759	+	#line 3760 "conf_parser.c"
3760		break;
3761
3762		case 179:
3763	<
3764	<	/* Line 1455 of yacc.c  */
4574	<	#line 1247 "ircd_parser.y"
4575	<	{
3763	>	#line 1048 "conf_parser.y"
3764	>	{
3765		if (conf_parser_ctx.pass == 2)
3766	<	yy_aconf->modes |= UMODE_INVISIBLE;
3766	>	block_state.modes.value |= UMODE_DEAF;
3767		}
3768	+	#line 3769 "conf_parser.c"
3769		break;
3770
3771		case 180:
3772	<
3773	<	/* Line 1455 of yacc.c  */
4584	<	#line 1251 "ircd_parser.y"
4585	<	{
3772	>	#line 1052 "conf_parser.y"
3773	>	{
3774		if (conf_parser_ctx.pass == 2)
3775	<	yy_aconf->modes |= UMODE_WALLOP;
3775	>	block_state.modes.value |= UMODE_DEBUG;
3776		}
3777	+	#line 3778 "conf_parser.c"
3778		break;
3779
3780		case 181:
3781	<
3782	<	/* Line 1455 of yacc.c  */
4594	<	#line 1255 "ircd_parser.y"
4595	<	{
3781	>	#line 1056 "conf_parser.y"
3782	>	{
3783		if (conf_parser_ctx.pass == 2)
3784	<	yy_aconf->modes |= UMODE_SOFTCALLERID;
3784	>	block_state.modes.value |= UMODE_FLOOD;
3785		}
3786	+	#line 3787 "conf_parser.c"
3787		break;
3788
3789		case 182:
3790	<
3791	<	/* Line 1455 of yacc.c  */
4604	<	#line 1259 "ircd_parser.y"
4605	<	{
3790	>	#line 1060 "conf_parser.y"
3791	>	{
3792		if (conf_parser_ctx.pass == 2)
3793	<	yy_aconf->modes |= UMODE_CALLERID;
3793	>	block_state.modes.value |= UMODE_HIDDEN;
3794		}
3795	+	#line 3796 "conf_parser.c"
3796		break;
3797
3798		case 183:
3799	<
3800	<	/* Line 1455 of yacc.c  */
4614	<	#line 1263 "ircd_parser.y"
4615	<	{
3799	>	#line 1064 "conf_parser.y"
3800	>	{
3801		if (conf_parser_ctx.pass == 2)
3802	<	yy_aconf->modes |= UMODE_LOCOPS;
3802	>	block_state.modes.value |= UMODE_HIDECHANS;
3803		}
3804	+	#line 3805 "conf_parser.c"
3805		break;
3806
3807		case 184:
3808	<
3809	<	/* Line 1455 of yacc.c  */
4624	<	#line 1269 "ircd_parser.y"
4625	<	{
3808	>	#line 1068 "conf_parser.y"
3809	>	{
3810		if (conf_parser_ctx.pass == 2)
3811	<	{
4628	<	if (yylval.number)
4629	<	yy_aconf->port |= OPER_FLAG_GLOBAL_KILL;
4630	<	else
4631	<	yy_aconf->port &= ~OPER_FLAG_GLOBAL_KILL;
4632	<	}
3811	>	block_state.modes.value |= UMODE_HIDEIDLE;
3812		}
3813	+	#line 3814 "conf_parser.c"
3814		break;
3815
3816		case 185:
3817	<
3818	<	/* Line 1455 of yacc.c  */
4639	<	#line 1280 "ircd_parser.y"
4640	<	{
3817	>	#line 1072 "conf_parser.y"
3818	>	{
3819		if (conf_parser_ctx.pass == 2)
3820	<	{
4643	<	if (yylval.number)
4644	<	yy_aconf->port |= OPER_FLAG_REMOTE;
4645	<	else
4646	<	yy_aconf->port &= ~OPER_FLAG_REMOTE;
4647	<	}
3820	>	block_state.modes.value |= UMODE_SKILL;
3821		}
3822	+	#line 3823 "conf_parser.c"
3823		break;
3824
3825		case 186:
3826	<
3827	<	/* Line 1455 of yacc.c  */
4654	<	#line 1291 "ircd_parser.y"
4655	<	{
3826	>	#line 1076 "conf_parser.y"
3827	>	{
3828		if (conf_parser_ctx.pass == 2)
3829	<	{
4658	<	if (yylval.number)
4659	<	yy_aconf->port |= OPER_FLAG_REMOTEBAN;
4660	<	else
4661	<	yy_aconf->port &= ~OPER_FLAG_REMOTEBAN;
4662	<	}
3829	>	block_state.modes.value |= UMODE_NCHANGE;
3830		}
3831	+	#line 3832 "conf_parser.c"
3832		break;
3833
3834		case 187:
3835	<
3836	<	/* Line 1455 of yacc.c  */
4669	<	#line 1302 "ircd_parser.y"
4670	<	{
3835	>	#line 1080 "conf_parser.y"
3836	>	{
3837		if (conf_parser_ctx.pass == 2)
3838	<	{
4673	<	if (yylval.number)
4674	<	yy_aconf->port |= OPER_FLAG_K;
4675	<	else
4676	<	yy_aconf->port &= ~OPER_FLAG_K;
4677	<	}
3838	>	block_state.modes.value |= UMODE_REJ;
3839		}
3840	+	#line 3841 "conf_parser.c"
3841		break;
3842
3843		case 188:
3844	<
3845	<	/* Line 1455 of yacc.c  */
4684	<	#line 1313 "ircd_parser.y"
4685	<	{
3844	>	#line 1084 "conf_parser.y"
3845	>	{
3846		if (conf_parser_ctx.pass == 2)
3847	<	{
4688	<	if (yylval.number)
4689	<	yy_aconf->port |= OPER_FLAG_X;
4690	<	else
4691	<	yy_aconf->port &= ~OPER_FLAG_X;
4692	<	}
3847	>	block_state.modes.value |= UMODE_SPY;
3848		}
3849	+	#line 3850 "conf_parser.c"
3850		break;
3851
3852		case 189:
3853	<
3854	<	/* Line 1455 of yacc.c  */
4699	<	#line 1324 "ircd_parser.y"
4700	<	{
3853	>	#line 1088 "conf_parser.y"
3854	>	{
3855		if (conf_parser_ctx.pass == 2)
3856	<	{
4703	<	if (yylval.number)
4704	<	yy_aconf->port |= OPER_FLAG_UNKLINE;
4705	<	else
4706	<	yy_aconf->port &= ~OPER_FLAG_UNKLINE;
4707	<	}
3856	>	block_state.modes.value |= UMODE_EXTERNAL;
3857		}
3858	+	#line 3859 "conf_parser.c"
3859		break;
3860
3861		case 190:
3862	<
3863	<	/* Line 1455 of yacc.c  */
4714	<	#line 1335 "ircd_parser.y"
4715	<	{
3862	>	#line 1092 "conf_parser.y"
3863	>	{
3864		if (conf_parser_ctx.pass == 2)
3865	<	{
4718	<	if (yylval.number)
4719	<	yy_aconf->port |= OPER_FLAG_GLINE;
4720	<	else
4721	<	yy_aconf->port &= ~OPER_FLAG_GLINE;
4722	<	}
3865	>	block_state.modes.value |= UMODE_SERVNOTICE;
3866		}
3867	+	#line 3868 "conf_parser.c"
3868		break;
3869
3870		case 191:
3871	<
3872	<	/* Line 1455 of yacc.c  */
4729	<	#line 1346 "ircd_parser.y"
4730	<	{
3871	>	#line 1096 "conf_parser.y"
3872	>	{
3873		if (conf_parser_ctx.pass == 2)
3874	<	{
4733	<	if (yylval.number)
4734	<	yy_aconf->port |= OPER_FLAG_N;
4735	<	else
4736	<	yy_aconf->port &= ~OPER_FLAG_N;
4737	<	}
3874	>	block_state.modes.value |= UMODE_INVISIBLE;
3875		}
3876	+	#line 3877 "conf_parser.c"
3877		break;
3878
3879		case 192:
3880	<
3881	<	/* Line 1455 of yacc.c  */
4744	<	#line 1357 "ircd_parser.y"
4745	<	{
3880	>	#line 1100 "conf_parser.y"
3881	>	{
3882		if (conf_parser_ctx.pass == 2)
3883	<	{
4748	<	if (yylval.number)
4749	<	yy_aconf->port |= OPER_FLAG_DIE;
4750	<	else
4751	<	yy_aconf->port &= ~OPER_FLAG_DIE;
4752	<	}
3883	>	block_state.modes.value |= UMODE_WALLOP;
3884		}
3885	+	#line 3886 "conf_parser.c"
3886		break;
3887
3888		case 193:
3889	<
3890	<	/* Line 1455 of yacc.c  */
4759	<	#line 1368 "ircd_parser.y"
4760	<	{
3889	>	#line 1104 "conf_parser.y"
3890	>	{
3891		if (conf_parser_ctx.pass == 2)
3892	<	{
4763	<	if (yylval.number)
4764	<	yy_aconf->port |= OPER_FLAG_REHASH;
4765	<	else
4766	<	yy_aconf->port &= ~OPER_FLAG_REHASH;
4767	<	}
3892	>	block_state.modes.value |= UMODE_SOFTCALLERID;
3893		}
3894	+	#line 3895 "conf_parser.c"
3895		break;
3896
3897		case 194:
3898	<
3899	<	/* Line 1455 of yacc.c  */
4774	<	#line 1379 "ircd_parser.y"
4775	<	{
3898	>	#line 1108 "conf_parser.y"
3899	>	{
3900		if (conf_parser_ctx.pass == 2)
3901	<	{
4778	<	if (yylval.number)
4779	<	yy_aconf->port |= OPER_FLAG_ADMIN;
4780	<	else
4781	<	yy_aconf->port &= ~OPER_FLAG_ADMIN;
4782	<	}
3901	>	block_state.modes.value |= UMODE_CALLERID;
3902		}
3903	+	#line 3904 "conf_parser.c"
3904		break;
3905
3906		case 195:
3907	<
3908	<	/* Line 1455 of yacc.c  */
4789	<	#line 1390 "ircd_parser.y"
4790	<	{
3907	>	#line 1112 "conf_parser.y"
3908	>	{
3909		if (conf_parser_ctx.pass == 2)
3910	<	{
4793	<	if (yylval.number)
4794	<	yy_aconf->port |= OPER_FLAG_HIDDEN_ADMIN;
4795	<	else
4796	<	yy_aconf->port &= ~OPER_FLAG_HIDDEN_ADMIN;
4797	<	}
3910	>	block_state.modes.value |= UMODE_LOCOPS;
3911		}
3912	+	#line 3913 "conf_parser.c"
3913		break;
3914
3915		case 196:
3916	<
3917	<	/* Line 1455 of yacc.c  */
4804	<	#line 1401 "ircd_parser.y"
4805	<	{
3916	>	#line 1116 "conf_parser.y"
3917	>	{
3918		if (conf_parser_ctx.pass == 2)
3919	<	{
4808	<	if (yylval.number)
4809	<	yy_aconf->port |= OPER_FLAG_HIDDEN_OPER;
4810	<	else
4811	<	yy_aconf->port &= ~OPER_FLAG_HIDDEN_OPER;
4812	<	}
3919	>	block_state.modes.value |= UMODE_REGONLY;
3920		}
3921	+	#line 3922 "conf_parser.c"
3922		break;
3923
3924		case 197:
3925	<
3926	<	/* Line 1455 of yacc.c  */
4819	<	#line 1412 "ircd_parser.y"
4820	<	{
3925	>	#line 1120 "conf_parser.y"
3926	>	{
3927		if (conf_parser_ctx.pass == 2)
3928	<	{
4823	<	if (yylval.number)
4824	<	yy_aconf->port |= OPER_FLAG_OPERWALL;
4825	<	else
4826	<	yy_aconf->port &= ~OPER_FLAG_OPERWALL;
4827	<	}
3928	>	block_state.modes.value |= UMODE_FARCONNECT;
3929		}
3930	+	#line 3931 "conf_parser.c"
3931		break;
3932
3933		case 198:
3934	<
3935	<	/* Line 1455 of yacc.c  */
3936	<	#line 1423 "ircd_parser.y"
3937	<	{
3934	>	#line 1124 "conf_parser.y"
3935	>	{
3936	>	if (conf_parser_ctx.pass == 2)
3937	>	block_state.modes.value |= UMODE_EXPIRATION;
3938		}
3939	+	#line 3940 "conf_parser.c"
3940		break;
3941
3942	<	case 202:
3942	>	case 199:
3943	>	#line 1130 "conf_parser.y"
3944	>	{
3945	>	if (conf_parser_ctx.pass == 2)
3946	>	block_state.port.value = 0;
3947	>	}
3948	>	#line 3949 "conf_parser.c"
3949	>	break;
3950
3951	<	/* Line 1455 of yacc.c  */
3952	<	#line 1427 "ircd_parser.y"
3953	<	{ not_atom = 1; }
3951	>	case 203:
3952	>	#line 1137 "conf_parser.y"
3953	>	{
3954	>	if (conf_parser_ctx.pass == 2)
3955	>	block_state.port.value |= OPER_FLAG_KILL_REMOTE;
3956	>	}
3957	>	#line 3958 "conf_parser.c"
3958		break;
3959
3960		case 204:
3961	+	#line 1141 "conf_parser.y"
3962	+	{
3963	+	if (conf_parser_ctx.pass == 2)
3964	+	block_state.port.value |= OPER_FLAG_KILL;
3965	+	}
3966	+	#line 3967 "conf_parser.c"
3967	+	break;
3968
3969	<	/* Line 1455 of yacc.c  */
3970	<	#line 1428 "ircd_parser.y"
3971	<	{ not_atom = 0; }
3969	>	case 205:
3970	>	#line 1145 "conf_parser.y"
3971	>	{
3972	>	if (conf_parser_ctx.pass == 2)
3973	>	block_state.port.value |= OPER_FLAG_CONNECT_REMOTE;
3974	>	}
3975	>	#line 3976 "conf_parser.c"
3976		break;
3977
3978		case 206:
3979	<
3980	<	/* Line 1455 of yacc.c  */
4856	<	#line 1431 "ircd_parser.y"
4857	<	{
3979	>	#line 1149 "conf_parser.y"
3980	>	{
3981		if (conf_parser_ctx.pass == 2)
3982	<	{
4860	<	if (not_atom)yy_aconf->port &= ~OPER_FLAG_GLOBAL_KILL;
4861	<	else yy_aconf->port |= OPER_FLAG_GLOBAL_KILL;
4862	<	}
3982	>	block_state.port.value |= OPER_FLAG_CONNECT;
3983		}
3984	+	#line 3985 "conf_parser.c"
3985		break;
3986
3987		case 207:
3988	<
3989	<	/* Line 1455 of yacc.c  */
4869	<	#line 1438 "ircd_parser.y"
4870	<	{
3988	>	#line 1153 "conf_parser.y"
3989	>	{
3990		if (conf_parser_ctx.pass == 2)
3991	<	{
4873	<	if (not_atom) yy_aconf->port &= ~OPER_FLAG_REMOTE;
4874	<	else yy_aconf->port |= OPER_FLAG_REMOTE;
4875	<	}
3991	>	block_state.port.value |= OPER_FLAG_SQUIT_REMOTE;
3992		}
3993	+	#line 3994 "conf_parser.c"
3994		break;
3995
3996		case 208:
3997	<
3998	<	/* Line 1455 of yacc.c  */
4882	<	#line 1445 "ircd_parser.y"
4883	<	{
3997	>	#line 1157 "conf_parser.y"
3998	>	{
3999		if (conf_parser_ctx.pass == 2)
4000	<	{
4886	<	if (not_atom) yy_aconf->port &= ~OPER_FLAG_K;
4887	<	else yy_aconf->port |= OPER_FLAG_K;
4888	<	}
4000	>	block_state.port.value |= OPER_FLAG_SQUIT;
4001		}
4002	+	#line 4003 "conf_parser.c"
4003		break;
4004
4005		case 209:
4006	<
4007	<	/* Line 1455 of yacc.c  */
4895	<	#line 1452 "ircd_parser.y"
4896	<	{
4006	>	#line 1161 "conf_parser.y"
4007	>	{
4008		if (conf_parser_ctx.pass == 2)
4009	<	{
4899	<	if (not_atom) yy_aconf->port &= ~OPER_FLAG_UNKLINE;
4900	<	else yy_aconf->port |= OPER_FLAG_UNKLINE;
4901	<	}
4009	>	block_state.port.value |= OPER_FLAG_KLINE;
4010		}
4011	+	#line 4012 "conf_parser.c"
4012		break;
4013
4014		case 210:
4015	<
4016	<	/* Line 1455 of yacc.c  */
4908	<	#line 1459 "ircd_parser.y"
4909	<	{
4015	>	#line 1165 "conf_parser.y"
4016	>	{
4017		if (conf_parser_ctx.pass == 2)
4018	<	{
4912	<	if (not_atom) yy_aconf->port &= ~OPER_FLAG_X;
4913	<	else yy_aconf->port |= OPER_FLAG_X;
4914	<	}
4018	>	block_state.port.value |= OPER_FLAG_UNKLINE;
4019		}
4020	+	#line 4021 "conf_parser.c"
4021		break;
4022
4023		case 211:
4024	<
4025	<	/* Line 1455 of yacc.c  */
4921	<	#line 1466 "ircd_parser.y"
4922	<	{
4024	>	#line 1169 "conf_parser.y"
4025	>	{
4026		if (conf_parser_ctx.pass == 2)
4027	<	{
4925	<	if (not_atom) yy_aconf->port &= ~OPER_FLAG_GLINE;
4926	<	else yy_aconf->port |= OPER_FLAG_GLINE;
4927	<	}
4027	>	block_state.port.value |= OPER_FLAG_DLINE;
4028		}
4029	+	#line 4030 "conf_parser.c"
4030		break;
4031
4032		case 212:
4033	<
4034	<	/* Line 1455 of yacc.c  */
4934	<	#line 1473 "ircd_parser.y"
4935	<	{
4033	>	#line 1173 "conf_parser.y"
4034	>	{
4035		if (conf_parser_ctx.pass == 2)
4036	<	{
4938	<	if (not_atom) yy_aconf->port &= ~OPER_FLAG_DIE;
4939	<	else yy_aconf->port |= OPER_FLAG_DIE;
4940	<	}
4036	>	block_state.port.value |= OPER_FLAG_UNDLINE;
4037		}
4038	+	#line 4039 "conf_parser.c"
4039		break;
4040
4041		case 213:
4042	<
4043	<	/* Line 1455 of yacc.c  */
4947	<	#line 1480 "ircd_parser.y"
4948	<	{
4042	>	#line 1177 "conf_parser.y"
4043	>	{
4044		if (conf_parser_ctx.pass == 2)
4045	<	{
4951	<	if (not_atom) yy_aconf->port &= ~OPER_FLAG_REHASH;
4952	<	else yy_aconf->port |= OPER_FLAG_REHASH;
4953	<	}
4045	>	block_state.port.value |= OPER_FLAG_XLINE;
4046		}
4047	+	#line 4048 "conf_parser.c"
4048		break;
4049
4050		case 214:
4051	<
4052	<	/* Line 1455 of yacc.c  */
4960	<	#line 1487 "ircd_parser.y"
4961	<	{
4051	>	#line 1181 "conf_parser.y"
4052	>	{
4053		if (conf_parser_ctx.pass == 2)
4054	<	{
4964	<	if (not_atom) yy_aconf->port &= ~OPER_FLAG_ADMIN;
4965	<	else yy_aconf->port |= OPER_FLAG_ADMIN;
4966	<	}
4054	>	block_state.port.value |= OPER_FLAG_UNXLINE;
4055		}
4056	+	#line 4057 "conf_parser.c"
4057		break;
4058
4059		case 215:
4060	<
4061	<	/* Line 1455 of yacc.c  */
4973	<	#line 1494 "ircd_parser.y"
4974	<	{
4060	>	#line 1185 "conf_parser.y"
4061	>	{
4062		if (conf_parser_ctx.pass == 2)
4063	<	{
4977	<	if (not_atom) yy_aconf->port &= ~OPER_FLAG_HIDDEN_ADMIN;
4978	<	else yy_aconf->port |= OPER_FLAG_HIDDEN_ADMIN;
4979	<	}
4063	>	block_state.port.value |= OPER_FLAG_DIE;
4064		}
4065	+	#line 4066 "conf_parser.c"
4066		break;
4067
4068		case 216:
4069	<
4070	<	/* Line 1455 of yacc.c  */
4986	<	#line 1501 "ircd_parser.y"
4987	<	{
4069	>	#line 1189 "conf_parser.y"
4070	>	{
4071		if (conf_parser_ctx.pass == 2)
4072	<	{
4990	<	if (not_atom) yy_aconf->port &= ~OPER_FLAG_N;
4991	<	else yy_aconf->port |= OPER_FLAG_N;
4992	<	}
4072	>	block_state.port.value |= OPER_FLAG_RESTART;
4073		}
4074	+	#line 4075 "conf_parser.c"
4075		break;
4076
4077		case 217:
4078	<
4079	<	/* Line 1455 of yacc.c  */
4999	<	#line 1508 "ircd_parser.y"
5000	<	{
4078	>	#line 1193 "conf_parser.y"
4079	>	{
4080		if (conf_parser_ctx.pass == 2)
4081	<	{
5003	<	if (not_atom) yy_aconf->port &= ~OPER_FLAG_OPERWALL;
5004	<	else yy_aconf->port |= OPER_FLAG_OPERWALL;
5005	<	}
4081	>	block_state.port.value |= OPER_FLAG_REHASH_REMOTE;
4082		}
4083	+	#line 4084 "conf_parser.c"
4084		break;
4085
4086		case 218:
4087	<
4088	<	/* Line 1455 of yacc.c  */
5012	<	#line 1515 "ircd_parser.y"
5013	<	{
4087	>	#line 1197 "conf_parser.y"
4088	>	{
4089		if (conf_parser_ctx.pass == 2)
4090	<	{
5016	<	if (not_atom) yy_aconf->port &= ~OPER_FLAG_OPER_SPY;
5017	<	else yy_aconf->port |= OPER_FLAG_OPER_SPY;
5018	<	}
4090	>	block_state.port.value |= OPER_FLAG_REHASH;
4091		}
4092	+	#line 4093 "conf_parser.c"
4093		break;
4094
4095		case 219:
4096	<
4097	<	/* Line 1455 of yacc.c  */
5025	<	#line 1522 "ircd_parser.y"
5026	<	{
4096	>	#line 1201 "conf_parser.y"
4097	>	{
4098		if (conf_parser_ctx.pass == 2)
4099	<	{
5029	<	if (not_atom) yy_aconf->port &= ~OPER_FLAG_HIDDEN_OPER;
5030	<	else yy_aconf->port |= OPER_FLAG_HIDDEN_OPER;
5031	<	}
4099	>	block_state.port.value |= OPER_FLAG_ADMIN;
4100		}
4101	+	#line 4102 "conf_parser.c"
4102		break;
4103
4104		case 220:
4105	<
4106	<	/* Line 1455 of yacc.c  */
5038	<	#line 1529 "ircd_parser.y"
5039	<	{
4105	>	#line 1205 "conf_parser.y"
4106	>	{
4107		if (conf_parser_ctx.pass == 2)
4108	<	{
5042	<	if (not_atom) yy_aconf->port &= ~OPER_FLAG_REMOTEBAN;
5043	<	else yy_aconf->port |= OPER_FLAG_REMOTEBAN;
5044	<	}
4108	>	block_state.port.value |= OPER_FLAG_GLOBOPS;
4109		}
4110	+	#line 4111 "conf_parser.c"
4111		break;
4112
4113		case 221:
4114	<
4115	<	/* Line 1455 of yacc.c  */
5051	<	#line 1536 "ircd_parser.y"
5052	<	{
4114	>	#line 1209 "conf_parser.y"
4115	>	{
4116		if (conf_parser_ctx.pass == 2)
4117	<	{
5055	<	if (not_atom) ClearConfEncrypted(yy_aconf);
5056	<	else SetConfEncrypted(yy_aconf);
5057	<	}
4117	>	block_state.port.value |= OPER_FLAG_WALLOPS;
4118		}
4119	+	#line 4120 "conf_parser.c"
4120		break;
4121
4122		case 222:
4123	<
4124	<	/* Line 1455 of yacc.c  */
4125	<	#line 1549 "ircd_parser.y"
4126	<	{
5066	<	if (conf_parser_ctx.pass == 1)
5067	<	{
5068	<	yy_conf = make_conf_item(CLASS_TYPE);
5069	<	yy_class = map_to_conf(yy_conf);
5070	<	}
4123	>	#line 1213 "conf_parser.y"
4124	>	{
4125	>	if (conf_parser_ctx.pass == 2)
4126	>	block_state.port.value |= OPER_FLAG_LOCOPS;
4127		}
4128	+	#line 4129 "conf_parser.c"
4129		break;
4130
4131		case 223:
4132	<
4133	<	/* Line 1455 of yacc.c  */
4134	<	#line 1556 "ircd_parser.y"
4135	<	{
5079	<	if (conf_parser_ctx.pass == 1)
5080	<	{
5081	<	struct ConfItem *cconf = NULL;
5082	<	struct ClassItem *class = NULL;
5083	<
5084	<	if (yy_class_name == NULL)
5085	<	delete_conf_item(yy_conf);
5086	<	else
5087	<	{
5088	<	cconf = find_exact_name_conf(CLASS_TYPE, yy_class_name, NULL, NULL);
5089	<
5090	<	if (cconf != NULL)                /* The class existed already */
5091	<	{
5092	<	int user_count = 0;
5093	<
5094	<	rebuild_cidr_class(cconf, yy_class);
5095	<
5096	<	class = map_to_conf(cconf);
5097	<
5098	<	user_count = class->curr_user_count;
5099	<	memcpy(class, yy_class, sizeof(*class));
5100	<	class->curr_user_count = user_count;
5101	<	class->active = 1;
5102	<
5103	<	delete_conf_item(yy_conf);
5104	<
5105	<	MyFree(cconf->name);            /* Allows case change of class name */
5106	<	cconf->name = yy_class_name;
5107	<	}
5108	<	else      /* Brand new class */
5109	<	{
5110	<	MyFree(yy_conf->name);          /* just in case it was allocated */
5111	<	yy_conf->name = yy_class_name;
5112	<	yy_class->active = 1;
5113	<	}
5114	<	}
5115	<
5116	<	yy_class_name = NULL;
5117	<	}
4132	>	#line 1217 "conf_parser.y"
4133	>	{
4134	>	if (conf_parser_ctx.pass == 2)
4135	>	block_state.port.value |= OPER_FLAG_REMOTEBAN;
4136		}
4137	+	#line 4138 "conf_parser.c"
4138		break;
4139
4140	<	case 242:
4141	<
4142	<	/* Line 1455 of yacc.c  */
4143	<	#line 1616 "ircd_parser.y"
4144	<	{
5126	<	if (conf_parser_ctx.pass == 1)
5127	<	{
5128	<	MyFree(yy_class_name);
5129	<	DupString(yy_class_name, yylval.string);
5130	<	}
4140	>	case 224:
4141	>	#line 1221 "conf_parser.y"
4142	>	{
4143	>	if (conf_parser_ctx.pass == 2)
4144	>	block_state.port.value |= OPER_FLAG_SET;
4145		}
4146	+	#line 4147 "conf_parser.c"
4147		break;
4148
4149	<	case 243:
4150	<
4151	<	/* Line 1455 of yacc.c  */
4152	<	#line 1625 "ircd_parser.y"
4153	<	{
5139	<	if (conf_parser_ctx.pass == 1)
5140	<	{
5141	<	MyFree(yy_class_name);
5142	<	DupString(yy_class_name, yylval.string);
5143	<	}
4149	>	case 225:
4150	>	#line 1225 "conf_parser.y"
4151	>	{
4152	>	if (conf_parser_ctx.pass == 2)
4153	>	block_state.port.value |= OPER_FLAG_MODULE;
4154		}
4155	+	#line 4156 "conf_parser.c"
4156		break;
4157
4158	<	case 244:
4159	<
4160	<	/* Line 1455 of yacc.c  */
4161	<	#line 1634 "ircd_parser.y"
4162	<	{
5152	<	if (conf_parser_ctx.pass == 1)
5153	<	PingFreq(yy_class) = (yyvsp[(3) - (4)].number);
4158	>	case 226:
4159	>	#line 1229 "conf_parser.y"
4160	>	{
4161	>	if (conf_parser_ctx.pass == 2)
4162	>	block_state.port.value |= OPER_FLAG_OPME;
4163		}
4164	+	#line 4165 "conf_parser.c"
4165		break;
4166
4167	<	case 245:
4168	<
4169	<	/* Line 1455 of yacc.c  */
4170	<	#line 1640 "ircd_parser.y"
4171	<	{
5162	<	if (conf_parser_ctx.pass == 1)
5163	<	PingWarning(yy_class) = (yyvsp[(3) - (4)].number);
4167	>	case 227:
4168	>	#line 1233 "conf_parser.y"
4169	>	{
4170	>	if (conf_parser_ctx.pass == 2)
4171	>	block_state.port.value |= OPER_FLAG_NICK_RESV;
4172		}
4173	+	#line 4174 "conf_parser.c"
4174		break;
4175
4176	<	case 246:
4177	<
4178	<	/* Line 1455 of yacc.c  */
4179	<	#line 1646 "ircd_parser.y"
4180	<	{
5172	<	if (conf_parser_ctx.pass == 1)
5173	<	MaxPerIp(yy_class) = (yyvsp[(3) - (4)].number);
4176	>	case 228:
4177	>	#line 1237 "conf_parser.y"
4178	>	{
4179	>	if (conf_parser_ctx.pass == 2)
4180	>	block_state.port.value |= OPER_FLAG_JOIN_RESV;
4181		}
4182	+	#line 4183 "conf_parser.c"
4183		break;
4184
4185	<	case 247:
4186	<
4187	<	/* Line 1455 of yacc.c  */
4188	<	#line 1652 "ircd_parser.y"
4189	<	{
5182	<	if (conf_parser_ctx.pass == 1)
5183	<	ConFreq(yy_class) = (yyvsp[(3) - (4)].number);
4185	>	case 229:
4186	>	#line 1241 "conf_parser.y"
4187	>	{
4188	>	if (conf_parser_ctx.pass == 2)
4189	>	block_state.port.value |= OPER_FLAG_RESV;
4190		}
4191	+	#line 4192 "conf_parser.c"
4192		break;
4193
4194	<	case 248:
4194	>	case 230:
4195	>	#line 1245 "conf_parser.y"
4196	>	{
4197	>	if (conf_parser_ctx.pass == 2)
4198	>	block_state.port.value |= OPER_FLAG_UNRESV;
4199	>	}
4200	>	#line 4201 "conf_parser.c"
4201	>	break;
4202
4203	<	/* Line 1455 of yacc.c  */
4204	<	#line 1658 "ircd_parser.y"
4205	<	{
4206	<	if (conf_parser_ctx.pass == 1)
4207	<	MaxTotal(yy_class) = (yyvsp[(3) - (4)].number);
4203	>	case 231:
4204	>	#line 1249 "conf_parser.y"
4205	>	{
4206	>	if (conf_parser_ctx.pass == 2)
4207	>	block_state.port.value |= OPER_FLAG_CLOSE;
4208		}
4209	+	#line 4210 "conf_parser.c"
4210		break;
4211
4212	<	case 249:
4212	>	case 232:
4213	>	#line 1259 "conf_parser.y"
4214	>	{
4215	>	if (conf_parser_ctx.pass != 1)
4216	>	break;
4217
4218	<	/* Line 1455 of yacc.c  */
4219	<	#line 1664 "ircd_parser.y"
4220	<	{
4221	<	if (conf_parser_ctx.pass == 1)
4222	<	MaxGlobal(yy_class) = (yyvsp[(3) - (4)].number);
4218	>	reset_block_state();
4219	>
4220	>	block_state.ping_freq.value = DEFAULT_PINGFREQUENCY;
4221	>	block_state.con_freq.value  = DEFAULT_CONNECTFREQUENCY;
4222	>	block_state.max_sendq.value = DEFAULT_SENDQ;
4223	>	block_state.max_recvq.value = DEFAULT_RECVQ;
4224		}
4225	+	#line 4226 "conf_parser.c"
4226		break;
4227
4228	<	case 250:
4228	>	case 233:
4229	>	#line 1270 "conf_parser.y"
4230	>	{
4231	>	if (conf_parser_ctx.pass != 1)
4232	>	break;
4233
4234	<	/* Line 1455 of yacc.c  */
5210	<	#line 1670 "ircd_parser.y"
5211	<	{
5212	<	if (conf_parser_ctx.pass == 1)
5213	<	MaxLocal(yy_class) = (yyvsp[(3) - (4)].number);
5214	<	}
4234	>	if (!block_state.class.buf[0])
4235		break;
4236
4237	<	case 251:
4237	>	struct ClassItem *class = class_find(block_state.class.buf, false);
4238	>	if (class == NULL)
4239	>	class = class_make();
4240
4241	<	/* Line 1455 of yacc.c  */
4242	<	#line 1676 "ircd_parser.y"
4243	<	{
4244	<	if (conf_parser_ctx.pass == 1)
4245	<	MaxIdent(yy_class) = (yyvsp[(3) - (4)].number);
4241	>	class->active = true;
4242	>	xfree(class->name);
4243	>	class->name = xstrdup(block_state.class.buf);
4244	>	class->ping_freq = block_state.ping_freq.value;
4245	>	class->max_perip_local = block_state.max_perip_local.value;
4246	>	class->max_perip_global = block_state.max_perip_global.value;
4247	>	class->con_freq = block_state.con_freq.value;
4248	>	class->max_total = block_state.max_total.value;
4249	>	class->max_sendq = block_state.max_sendq.value;
4250	>	class->max_recvq = block_state.max_recvq.value;
4251	>	class->max_channels = block_state.max_channels.value;
4252	>
4253	>	if (block_state.min_idle.value > block_state.max_idle.value)
4254	>	{
4255	>	block_state.min_idle.value = 0;
4256	>	block_state.max_idle.value = 0;
4257	>	block_state.flags.value &= ~CLASS_FLAGS_FAKE_IDLE;
4258	>	}
4259	>
4260	>	class->flags = block_state.flags.value;
4261	>	class->min_idle = block_state.min_idle.value;
4262	>	class->max_idle = block_state.max_idle.value;
4263	>
4264	>	bool diff = (class->cidr_bitlen_ipv4 != block_state.cidr_bitlen_ipv4.value ||
4265	>	class->cidr_bitlen_ipv6 != block_state.cidr_bitlen_ipv6.value);
4266	>	class->cidr_bitlen_ipv4 = block_state.cidr_bitlen_ipv4.value;
4267	>	class->cidr_bitlen_ipv6 = block_state.cidr_bitlen_ipv6.value;
4268	>	class->number_per_cidr = block_state.number_per_cidr.value;
4269	>
4270	>	if (diff)
4271	>	class_ip_limit_rebuild(class);
4272		}
4273	+	#line 4274 "conf_parser.c"
4274		break;
4275
4276		case 252:
4277	<
4278	<	/* Line 1455 of yacc.c  */
5230	<	#line 1682 "ircd_parser.y"
5231	<	{
4277	>	#line 1333 "conf_parser.y"
4278	>	{
4279		if (conf_parser_ctx.pass == 1)
4280	<	MaxSendq(yy_class) = (yyvsp[(3) - (4)].number);
4280	>	strlcpy(block_state.class.buf, yylval.string, sizeof(block_state.class.buf));
4281		}
4282	+	#line 4283 "conf_parser.c"
4283		break;
4284
4285		case 253:
4286	<
4287	<	/* Line 1455 of yacc.c  */
5240	<	#line 1688 "ircd_parser.y"
5241	<	{
4286	>	#line 1339 "conf_parser.y"
4287	>	{
4288		if (conf_parser_ctx.pass == 1)
4289	<	CidrBitlenIPV4(yy_class) = (yyvsp[(3) - (4)].number);
4289	>	block_state.ping_freq.value = (yyvsp[-1].number);
4290		}
4291	+	#line 4292 "conf_parser.c"
4292		break;
4293
4294		case 254:
4295	<
4296	<	/* Line 1455 of yacc.c  */
5250	<	#line 1694 "ircd_parser.y"
5251	<	{
4295	>	#line 1345 "conf_parser.y"
4296	>	{
4297		if (conf_parser_ctx.pass == 1)
4298	<	CidrBitlenIPV6(yy_class) = (yyvsp[(3) - (4)].number);
4298	>	block_state.max_perip_local.value = (yyvsp[-1].number);
4299		}
4300	+	#line 4301 "conf_parser.c"
4301		break;
4302
4303		case 255:
4304	<
4305	<	/* Line 1455 of yacc.c  */
5260	<	#line 1700 "ircd_parser.y"
5261	<	{
4304	>	#line 1351 "conf_parser.y"
4305	>	{
4306		if (conf_parser_ctx.pass == 1)
4307	<	NumberPerCidr(yy_class) = (yyvsp[(3) - (4)].number);
4307	>	block_state.max_perip_global.value = (yyvsp[-1].number);
4308		}
4309	+	#line 4310 "conf_parser.c"
4310		break;
4311
4312		case 256:
4313	<
4314	<	/* Line 1455 of yacc.c  */
4315	<	#line 1709 "ircd_parser.y"
4316	<	{
5272	<	if (conf_parser_ctx.pass == 2)
5273	<	{
5274	<	listener_address = NULL;
5275	<	listener_flags = 0;
5276	<	}
4313	>	#line 1357 "conf_parser.y"
4314	>	{
4315	>	if (conf_parser_ctx.pass == 1)
4316	>	block_state.con_freq.value = (yyvsp[-1].number);
4317		}
4318	+	#line 4319 "conf_parser.c"
4319		break;
4320
4321		case 257:
4322	<
4323	<	/* Line 1455 of yacc.c  */
4324	<	#line 1716 "ircd_parser.y"
4325	<	{
5285	<	if (conf_parser_ctx.pass == 2)
5286	<	{
5287	<	MyFree(listener_address);
5288	<	listener_address = NULL;
5289	<	}
4322	>	#line 1363 "conf_parser.y"
4323	>	{
4324	>	if (conf_parser_ctx.pass == 1)
4325	>	block_state.max_channels.value = (yyvsp[-1].number);
4326		}
4327	+	#line 4328 "conf_parser.c"
4328		break;
4329
4330		case 258:
4331	+	#line 1369 "conf_parser.y"
4332	+	{
4333	+	if (conf_parser_ctx.pass == 1)
4334	+	block_state.max_total.value = (yyvsp[-1].number);
4335	+	}
4336	+	#line 4337 "conf_parser.c"
4337	+	break;
4338
4339	<	/* Line 1455 of yacc.c  */
4340	<	#line 1725 "ircd_parser.y"
4341	<	{
4342	<	listener_flags = 0;
4339	>	case 259:
4340	>	#line 1375 "conf_parser.y"
4341	>	{
4342	>	if (conf_parser_ctx.pass == 1)
4343	>	block_state.max_sendq.value = (yyvsp[-1].number);
4344		}
4345	+	#line 4346 "conf_parser.c"
4346		break;
4347
4348	<	case 262:
4348	>	case 260:
4349	>	#line 1381 "conf_parser.y"
4350	>	{
4351	>	if (conf_parser_ctx.pass == 1)
4352	>	if ((yyvsp[-1].number) >= CLIENT_FLOOD_MIN && (yyvsp[-1].number) <= CLIENT_FLOOD_MAX)
4353	>	block_state.max_recvq.value = (yyvsp[-1].number);
4354	>	}
4355	>	#line 4356 "conf_parser.c"
4356	>	break;
4357
4358	<	/* Line 1455 of yacc.c  */
4359	<	#line 1731 "ircd_parser.y"
4360	<	{
4361	<	if (conf_parser_ctx.pass == 2)
4362	<	listener_flags |= LISTENER_SSL;
4358	>	case 261:
4359	>	#line 1388 "conf_parser.y"
4360	>	{
4361	>	if (conf_parser_ctx.pass == 1)
4362	>	block_state.cidr_bitlen_ipv4.value = (yyvsp[-1].number) > 32 ? 32 : (yyvsp[-1].number);
4363		}
4364	+	#line 4365 "conf_parser.c"
4365		break;
4366
4367	<	case 263:
4367	>	case 262:
4368	>	#line 1394 "conf_parser.y"
4369	>	{
4370	>	if (conf_parser_ctx.pass == 1)
4371	>	block_state.cidr_bitlen_ipv6.value = (yyvsp[-1].number) > 128 ? 128 : (yyvsp[-1].number);
4372	>	}
4373	>	#line 4374 "conf_parser.c"
4374	>	break;
4375
4376	<	/* Line 1455 of yacc.c  */
4377	<	#line 1735 "ircd_parser.y"
4378	<	{
4379	<	if (conf_parser_ctx.pass == 2)
4380	<	listener_flags |= LISTENER_HIDDEN;
4376	>	case 263:
4377	>	#line 1400 "conf_parser.y"
4378	>	{
4379	>	if (conf_parser_ctx.pass == 1)
4380	>	block_state.number_per_cidr.value = (yyvsp[-1].number);
4381		}
4382	+	#line 4383 "conf_parser.c"
4383		break;
4384
4385		case 264:
4386	+	#line 1406 "conf_parser.y"
4387	+	{
4388	+	if (conf_parser_ctx.pass != 1)
4389	+	break;
4390
4391	<	/* Line 1455 of yacc.c  */
4392	<	#line 1739 "ircd_parser.y"
5326	<	{
5327	<	if (conf_parser_ctx.pass == 2)
5328	<	listener_flags |= LISTENER_SERVER;
4391	>	block_state.min_idle.value = (yyvsp[-1].number);
4392	>	block_state.flags.value |= CLASS_FLAGS_FAKE_IDLE;
4393		}
4394	+	#line 4395 "conf_parser.c"
4395		break;
4396
4397	<	case 272:
4397	>	case 265:
4398	>	#line 1415 "conf_parser.y"
4399	>	{
4400	>	if (conf_parser_ctx.pass != 1)
4401	>	break;
4402
4403	<	/* Line 1455 of yacc.c  */
4404	<	#line 1749 "ircd_parser.y"
4405	<	{ listener_flags = 0; }
4403	>	block_state.max_idle.value = (yyvsp[-1].number);
4404	>	block_state.flags.value |= CLASS_FLAGS_FAKE_IDLE;
4405	>	}
4406	>	#line 4407 "conf_parser.c"
4407		break;
4408
4409	<	case 276:
4409	>	case 266:
4410	>	#line 1424 "conf_parser.y"
4411	>	{
4412	>	if (conf_parser_ctx.pass == 1)
4413	>	block_state.flags.value &= CLASS_FLAGS_FAKE_IDLE;
4414	>	}
4415	>	#line 4416 "conf_parser.c"
4416	>	break;
4417
4418	<	/* Line 1455 of yacc.c  */
4419	<	#line 1754 "ircd_parser.y"
4420	<	{
4421	<	if (conf_parser_ctx.pass == 2)
4422	<	{
5346	<	if ((listener_flags & LISTENER_SSL))
5347	<	#ifdef HAVE_LIBCRYPTO
5348	<	if (!ServerInfo.server_ctx)
5349	<	#endif
5350	<	{
5351	<	yyerror("SSL not available - port closed");
5352	<	break;
5353	<	}
5354	<	add_listener((yyvsp[(1) - (1)].number), listener_address, listener_flags);
5355	<	}
4418	>	case 270:
4419	>	#line 1431 "conf_parser.y"
4420	>	{
4421	>	if (conf_parser_ctx.pass == 1)
4422	>	block_state.flags.value |= CLASS_FLAGS_RANDOM_IDLE;
4423		}
4424	+	#line 4425 "conf_parser.c"
4425		break;
4426
4427	<	case 277:
4427	>	case 271:
4428	>	#line 1435 "conf_parser.y"
4429	>	{
4430	>	if (conf_parser_ctx.pass == 1)
4431	>	block_state.flags.value |= CLASS_FLAGS_HIDE_IDLE_FROM_OPERS;
4432	>	}
4433	>	#line 4434 "conf_parser.c"
4434	>	break;
4435
4436	<	/* Line 1455 of yacc.c  */
4437	<	#line 1768 "ircd_parser.y"
4438	<	{
4436	>	case 272:
4437	>	#line 1445 "conf_parser.y"
4438	>	{
4439		if (conf_parser_ctx.pass == 2)
4440	<	{
4441	<	int i;
4442	<
4443	<	if ((listener_flags & LISTENER_SSL))
5369	<	#ifdef HAVE_LIBCRYPTO
5370	<	if (!ServerInfo.server_ctx)
5371	<	#endif
5372	<	{
5373	<	yyerror("SSL not available - port closed");
5374	<	break;
5375	<	}
4440	>	reset_block_state();
4441	>	}
4442	>	#line 4443 "conf_parser.c"
4443	>	break;
4444
4445	<	for (i = (yyvsp[(1) - (3)].number); i <= (yyvsp[(3) - (3)].number); ++i)
4446	<	add_listener(i, listener_address, listener_flags);
4447	<	}
4445	>	case 274:
4446	>	#line 1451 "conf_parser.y"
4447	>	{
4448	>	block_state.flags.value = 0;
4449		}
4450	+	#line 4451 "conf_parser.c"
4451		break;
4452
4453		case 278:
4454	<
4455	<	/* Line 1455 of yacc.c  */
5386	<	#line 1788 "ircd_parser.y"
5387	<	{
4454	>	#line 1457 "conf_parser.y"
4455	>	{
4456		if (conf_parser_ctx.pass == 2)
4457	<	{
5390	<	MyFree(listener_address);
5391	<	DupString(listener_address, yylval.string);
5392	<	}
4457	>	block_state.flags.value |= LISTENER_TLS;
4458		}
4459	+	#line 4460 "conf_parser.c"
4460		break;
4461
4462		case 279:
4463	<
4464	<	/* Line 1455 of yacc.c  */
5399	<	#line 1797 "ircd_parser.y"
5400	<	{
4463	>	#line 1461 "conf_parser.y"
4464	>	{
4465		if (conf_parser_ctx.pass == 2)
4466	<	{
5403	<	MyFree(listener_address);
5404	<	DupString(listener_address, yylval.string);
5405	<	}
4466	>	block_state.flags.value |= LISTENER_HIDDEN;
4467		}
4468	+	#line 4469 "conf_parser.c"
4469		break;
4470
4471		case 280:
4472	<
4473	<	/* Line 1455 of yacc.c  */
5412	<	#line 1809 "ircd_parser.y"
5413	<	{
4472	>	#line 1465 "conf_parser.y"
4473	>	{
4474		if (conf_parser_ctx.pass == 2)
4475	<	{
5416	<	yy_conf = make_conf_item(CLIENT_TYPE);
5417	<	yy_aconf = map_to_conf(yy_conf);
5418	<	}
5419	<	else
5420	<	{
5421	<	MyFree(class_name);
5422	<	class_name = NULL;
5423	<	}
4475	>	block_state.flags.value |= LISTENER_SERVER;
4476		}
4477	+	#line 4478 "conf_parser.c"
4478		break;
4479
4480		case 281:
4481	<
4482	<	/* Line 1455 of yacc.c  */
5430	<	#line 1821 "ircd_parser.y"
5431	<	{
4481	>	#line 1469 "conf_parser.y"
4482	>	{
4483		if (conf_parser_ctx.pass == 2)
4484	<	{
4485	<	struct CollectItem *yy_tmp = NULL;
4486	<	dlink_node *ptr = NULL, *next_ptr = NULL;
4487	<
5437	<	if (yy_aconf->user && yy_aconf->host)
5438	<	{
5439	<	conf_add_class_to_conf(yy_conf, class_name);
5440	<	add_conf_by_address(CONF_CLIENT, yy_aconf);
5441	<	}
5442	<	else
5443	<	delete_conf_item(yy_conf);
5444	<
5445	<	/* copy over settings from first struct */
5446	<	DLINK_FOREACH_SAFE(ptr, next_ptr, col_conf_list.head)
5447	<	{
5448	<	struct AccessItem *new_aconf;
5449	<	struct ConfItem *new_conf;
5450	<
5451	<	new_conf = make_conf_item(CLIENT_TYPE);
5452	<	new_aconf = map_to_conf(new_conf);
5453	<
5454	<	yy_tmp = ptr->data;
5455	<
5456	<	assert(yy_tmp->user && yy_tmp->host);
5457	<
5458	<	if (yy_aconf->passwd != NULL)
5459	<	DupString(new_aconf->passwd, yy_aconf->passwd);
5460	<	if (yy_conf->name != NULL)
5461	<	DupString(new_conf->name, yy_conf->name);
5462	<	if (yy_aconf->passwd != NULL)
5463	<	DupString(new_aconf->passwd, yy_aconf->passwd);
5464	<
5465	<	new_aconf->flags = yy_aconf->flags;
5466	<	new_aconf->port  = yy_aconf->port;
5467	<
5468	<	DupString(new_aconf->user, yy_tmp->user);
5469	<	collapse(new_aconf->user);
5470	<
5471	<	DupString(new_aconf->host, yy_tmp->host);
5472	<	collapse(new_aconf->host);
5473	<
5474	<	conf_add_class_to_conf(new_conf, class_name);
5475	<	add_conf_by_address(CONF_CLIENT, new_aconf);
5476	<	dlinkDelete(&yy_tmp->node, &col_conf_list);
5477	<	free_collect_item(yy_tmp);
5478	<	}
4484	>	block_state.flags.value |= LISTENER_CLIENT;
4485	>	}
4486	>	#line 4487 "conf_parser.c"
4487	>	break;
4488
4489	<	MyFree(class_name);
4490	<	class_name = NULL;
4491	<	yy_conf = NULL;
4492	<	yy_aconf = NULL;
4493	<	}
4489	>	case 282:
4490	>	#line 1473 "conf_parser.y"
4491	>	{
4492	>	if (conf_parser_ctx.pass == 2)
4493	>	block_state.flags.value |= LISTENER_DEFER;
4494		}
4495	+	#line 4496 "conf_parser.c"
4496		break;
4497
4498	<	case 301:
4498	>	case 290:
4499	>	#line 1481 "conf_parser.y"
4500	>	{ block_state.flags.value = 0; }
4501	>	#line 4502 "conf_parser.c"
4502	>	break;
4503
4504	<	/* Line 1455 of yacc.c  */
4505	<	#line 1886 "ircd_parser.y"
4506	<	{
4504	>	case 294:
4505	>	#line 1486 "conf_parser.y"
4506	>	{
4507		if (conf_parser_ctx.pass == 2)
4508		{
4509	<	struct CollectItem *yy_tmp = NULL;
4510	<	struct split_nuh_item nuh;
5497	<
5498	<	nuh.nuhmask  = yylval.string;
5499	<	nuh.nickptr  = NULL;
5500	<	nuh.userptr  = userbuf;
5501	<	nuh.hostptr  = hostbuf;
5502	<
5503	<	nuh.nicksize = 0;
5504	<	nuh.usersize = sizeof(userbuf);
5505	<	nuh.hostsize = sizeof(hostbuf);
5506	<
5507	<	split_nuh(&nuh);
5508	<
5509	<	if (yy_aconf->user == NULL)
5510	<	{
5511	<	DupString(yy_aconf->user, userbuf);
5512	<	DupString(yy_aconf->host, hostbuf);
5513	<	}
5514	<	else
4509	>	#ifndef HAVE_TLS
4510	>	if (block_state.flags.value & LISTENER_TLS)
4511		{
4512	<	yy_tmp = MyMalloc(sizeof(struct CollectItem));
4513	<
5518	<	DupString(yy_tmp->user, userbuf);
5519	<	DupString(yy_tmp->host, hostbuf);
5520	<
5521	<	dlinkAdd(yy_tmp, &yy_tmp->node, &col_conf_list);
4512	>	conf_error_report("TLS not available - port closed");
4513	>	break;
4514		}
4515	+	#endif
4516	+	listener_add((yyvsp[0].number), block_state.addr.buf, block_state.flags.value);
4517		}
4518		}
4519	+	#line 4520 "conf_parser.c"
4520		break;
4521
4522	<	case 302:
4523	<
4524	<	/* Line 1455 of yacc.c  */
5530	<	#line 1923 "ircd_parser.y"
5531	<	{
4522	>	case 295:
4523	>	#line 1499 "conf_parser.y"
4524	>	{
4525		if (conf_parser_ctx.pass == 2)
4526		{
4527	<	/* be paranoid */
4528	<	if (yy_aconf->passwd != NULL)
4529	<	memset(yy_aconf->passwd, 0, strlen(yy_aconf->passwd));
4527	>	#ifndef HAVE_TLS
4528	>	if (block_state.flags.value & LISTENER_TLS)
4529	>	{
4530	>	conf_error_report("TLS not available - port closed");
4531	>	break;
4532	>	}
4533	>	#endif
4534
4535	<	MyFree(yy_aconf->passwd);
4536	<	DupString(yy_aconf->passwd, yylval.string);
4535	>	for (int i = (yyvsp[-2].number); i <= (yyvsp[0].number); ++i)
4536	>	listener_add(i, block_state.addr.buf, block_state.flags.value);
4537		}
4538		}
4539	+	#line 4540 "conf_parser.c"
4540		break;
4541
4542	<	case 303:
4543	<
4544	<	/* Line 1455 of yacc.c  */
5547	<	#line 1936 "ircd_parser.y"
5548	<	{
4542	>	case 296:
4543	>	#line 1516 "conf_parser.y"
4544	>	{
4545		if (conf_parser_ctx.pass == 2)
4546	<	{
5551	<	if (yylval.number)
5552	<	yy_aconf->flags |= CONF_FLAGS_SPOOF_NOTICE;
5553	<	else
5554	<	yy_aconf->flags &= ~CONF_FLAGS_SPOOF_NOTICE;
5555	<	}
4546	>	strlcpy(block_state.addr.buf, yylval.string, sizeof(block_state.addr.buf));
4547		}
4548	+	#line 4549 "conf_parser.c"
4549		break;
4550
4551	<	case 304:
4552	<
4553	<	/* Line 1455 of yacc.c  */
5562	<	#line 1947 "ircd_parser.y"
5563	<	{
4551	>	case 297:
4552	>	#line 1522 "conf_parser.y"
4553	>	{
4554		if (conf_parser_ctx.pass == 2)
4555	<	{
5566	<	MyFree(class_name);
5567	<	DupString(class_name, yylval.string);
5568	<	}
4555	>	strlcpy(block_state.addr.buf, yylval.string, sizeof(block_state.addr.buf));
4556		}
4557	+	#line 4558 "conf_parser.c"
4558		break;
4559
4560	<	case 305:
4561	<
4562	<	/* Line 1455 of yacc.c  */
5575	<	#line 1956 "ircd_parser.y"
5576	<	{
4560	>	case 298:
4561	>	#line 1532 "conf_parser.y"
4562	>	{
4563		if (conf_parser_ctx.pass == 2)
4564	<	{
5579	<	if (yylval.number)
5580	<	SetConfEncrypted(yy_aconf);
5581	<	else
5582	<	ClearConfEncrypted(yy_aconf);
5583	<	}
4564	>	reset_block_state();
4565		}
4566	+	#line 4567 "conf_parser.c"
4567		break;
4568
4569	<	case 306:
4569	>	case 299:
4570	>	#line 1536 "conf_parser.y"
4571	>	{
4572	>	dlink_node *node;
4573
4574	<	/* Line 1455 of yacc.c  */
5590	<	#line 1967 "ircd_parser.y"
5591	<	{
5592	<	}
4574	>	if (conf_parser_ctx.pass != 2)
4575		break;
4576
4577	<	case 310:
4577	>	DLINK_FOREACH(node, block_state.mask.list.head)
4578	>	{
4579	>	struct split_nuh_item nuh;
4580	>	char *s = node->data;
4581
4582	<	/* Line 1455 of yacc.c  */
4583	<	#line 1971 "ircd_parser.y"
5599	<	{ not_atom = 1; }
5600	<	break;
4582	>	if (EmptyString(s))
4583	>	continue;
4584
4585	<	case 312:
4585	>	nuh.nuhmask  = s;
4586	>	nuh.nickptr  = NULL;
4587	>	nuh.userptr  = block_state.user.buf;
4588	>	nuh.hostptr  = block_state.host.buf;
4589
4590	<	/* Line 1455 of yacc.c  */
4591	<	#line 1972 "ircd_parser.y"
4592	<	{ not_atom = 0; }
5607	<	break;
4590	>	nuh.nicksize = 0;
4591	>	nuh.usersize = sizeof(block_state.user.buf);
4592	>	nuh.hostsize = sizeof(block_state.host.buf);
4593
4594	<	case 314:
4594	>	split_nuh(&nuh);
4595
4596	<	/* Line 1455 of yacc.c  */
4597	<	#line 1975 "ircd_parser.y"
4598	<	{
5614	<	if (conf_parser_ctx.pass == 2)
5615	<	{
5616	<	if (not_atom) yy_aconf->flags &= ~CONF_FLAGS_SPOOF_NOTICE;
5617	<	else yy_aconf->flags |= CONF_FLAGS_SPOOF_NOTICE;
5618	<	}
4596	>	struct MaskItem *conf = conf_make(CONF_CLIENT);
4597	>	conf->user = xstrdup(block_state.user.buf);
4598	>	conf->host = xstrdup(block_state.host.buf);
4599
4600	<	}
4601	<	break;
4600	>	if (block_state.rpass.buf[0])
4601	>	conf->passwd = xstrdup(block_state.rpass.buf);
4602	>	if (block_state.name.buf[0])
4603	>	conf->name = xstrdup(block_state.name.buf);
4604
4605	<	case 315:
4605	>	conf->flags = block_state.flags.value;
4606	>	conf->port = block_state.port.value;
4607
4608	<	/* Line 1455 of yacc.c  */
4609	<	#line 1983 "ircd_parser.y"
5627	<	{
5628	<	if (conf_parser_ctx.pass == 2)
5629	<	{
5630	<	if (not_atom) yy_aconf->flags &= ~CONF_FLAGS_NOLIMIT;
5631	<	else yy_aconf->flags |= CONF_FLAGS_NOLIMIT;
4608	>	conf_add_class_to_conf(conf, block_state.class.buf);
4609	>	add_conf_by_address(CONF_CLIENT, conf);
4610		}
4611		}
4612	+	#line 4613 "conf_parser.c"
4613		break;
4614
4615	<	case 316:
4615	>	case 311:
4616	>	#line 1590 "conf_parser.y"
4617	>	{
4618	>	if (conf_parser_ctx.pass == 2)
4619	>	dlinkAdd(xstrdup(yylval.string), make_dlink_node(), &block_state.mask.list);
4620	>	}
4621	>	#line 4622 "conf_parser.c"
4622	>	break;
4623
4624	<	/* Line 1455 of yacc.c  */
4625	<	#line 1990 "ircd_parser.y"
4626	<	{
4624	>	case 312:
4625	>	#line 1596 "conf_parser.y"
4626	>	{
4627		if (conf_parser_ctx.pass == 2)
4628	<	{
5643	<	if (not_atom) yy_aconf->flags &= ~CONF_FLAGS_EXEMPTKLINE;
5644	<	else yy_aconf->flags |= CONF_FLAGS_EXEMPTKLINE;
5645	<	}
4628	>	strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
4629		}
4630	+	#line 4631 "conf_parser.c"
4631		break;
4632
4633	<	case 317:
4633	>	case 313:
4634	>	#line 1602 "conf_parser.y"
4635	>	{
4636	>	if (conf_parser_ctx.pass == 2)
4637	>	strlcpy(block_state.class.buf, yylval.string, sizeof(block_state.class.buf));
4638	>	}
4639	>	#line 4640 "conf_parser.c"
4640	>	break;
4641
4642	<	/* Line 1455 of yacc.c  */
4643	<	#line 1997 "ircd_parser.y"
4644	<	{
4642	>	case 314:
4643	>	#line 1608 "conf_parser.y"
4644	>	{
4645		if (conf_parser_ctx.pass == 2)
4646		{
4647	<	if (not_atom) yy_aconf->flags &= ~CONF_FLAGS_NEED_IDENTD;
4648	<	else yy_aconf->flags |= CONF_FLAGS_NEED_IDENTD;
4647	>	if (yylval.number)
4648	>	block_state.flags.value |= CONF_FLAGS_ENCRYPTED;
4649	>	else
4650	>	block_state.flags.value &= ~CONF_FLAGS_ENCRYPTED;
4651		}
4652		}
4653	+	#line 4654 "conf_parser.c"
4654		break;
4655
4656	<	case 318:
4657	<
4658	<	/* Line 1455 of yacc.c  */
5665	<	#line 2004 "ircd_parser.y"
5666	<	{
4656	>	case 315:
4657	>	#line 1619 "conf_parser.y"
4658	>	{
4659		if (conf_parser_ctx.pass == 2)
4660	<	{
5669	<	if (not_atom) yy_aconf->flags &= ~CONF_FLAGS_CAN_FLOOD;
5670	<	else yy_aconf->flags |= CONF_FLAGS_CAN_FLOOD;
5671	<	}
4660	>	block_state.flags.value &= (CONF_FLAGS_ENCRYPTED | CONF_FLAGS_SPOOF_IP);
4661		}
4662	+	#line 4663 "conf_parser.c"
4663		break;
4664
4665		case 319:
4666	<
4667	<	/* Line 1455 of yacc.c  */
5678	<	#line 2011 "ircd_parser.y"
5679	<	{
4666	>	#line 1626 "conf_parser.y"
4667	>	{
4668		if (conf_parser_ctx.pass == 2)
4669	<	{
5682	<	if (not_atom) yy_aconf->flags &= ~CONF_FLAGS_IDLE_LINED;
5683	<	else yy_aconf->flags |= CONF_FLAGS_IDLE_LINED;
5684	<	}
4669	>	block_state.flags.value |= CONF_FLAGS_NOLIMIT;
4670		}
4671	+	#line 4672 "conf_parser.c"
4672		break;
4673
4674		case 320:
4675	<
4676	<	/* Line 1455 of yacc.c  */
5691	<	#line 2018 "ircd_parser.y"
5692	<	{
4675	>	#line 1630 "conf_parser.y"
4676	>	{
4677		if (conf_parser_ctx.pass == 2)
4678	<	{
5695	<	if (not_atom) yy_aconf->flags &= ~CONF_FLAGS_NO_TILDE;
5696	<	else yy_aconf->flags |= CONF_FLAGS_NO_TILDE;
5697	<	}
4678	>	block_state.flags.value |= CONF_FLAGS_EXEMPTKLINE;
4679		}
4680	+	#line 4681 "conf_parser.c"
4681		break;
4682
4683		case 321:
4684	<
4685	<	/* Line 1455 of yacc.c  */
5704	<	#line 2025 "ircd_parser.y"
5705	<	{
4684	>	#line 1634 "conf_parser.y"
4685	>	{
4686		if (conf_parser_ctx.pass == 2)
4687	<	{
5708	<	if (not_atom) yy_aconf->flags &= ~CONF_FLAGS_EXEMPTGLINE;
5709	<	else yy_aconf->flags |= CONF_FLAGS_EXEMPTGLINE;
5710	<	}
4687	>	block_state.flags.value |= CONF_FLAGS_EXEMPTXLINE;
4688		}
4689	+	#line 4690 "conf_parser.c"
4690		break;
4691
4692		case 322:
4693	<
4694	<	/* Line 1455 of yacc.c  */
5717	<	#line 2032 "ircd_parser.y"
5718	<	{
4693	>	#line 1638 "conf_parser.y"
4694	>	{
4695		if (conf_parser_ctx.pass == 2)
4696	<	{
5721	<	if (not_atom) yy_aconf->flags &= ~CONF_FLAGS_EXEMPTRESV;
5722	<	else yy_aconf->flags |= CONF_FLAGS_EXEMPTRESV;
5723	<	}
4696	>	block_state.flags.value |= CONF_FLAGS_NEED_IDENTD;
4697		}
4698	+	#line 4699 "conf_parser.c"
4699		break;
4700
4701		case 323:
4702	<
4703	<	/* Line 1455 of yacc.c  */
5730	<	#line 2039 "ircd_parser.y"
5731	<	{
4702	>	#line 1642 "conf_parser.y"
4703	>	{
4704		if (conf_parser_ctx.pass == 2)
4705	<	{
5734	<	if (not_atom) yy_aconf->flags &= ~CONF_FLAGS_NEED_PASSWORD;
5735	<	else yy_aconf->flags |= CONF_FLAGS_NEED_PASSWORD;
5736	<	}
4705	>	block_state.flags.value |= CONF_FLAGS_CAN_FLOOD;
4706		}
4707	+	#line 4708 "conf_parser.c"
4708		break;
4709
4710		case 324:
4711	<
4712	<	/* Line 1455 of yacc.c  */
5743	<	#line 2048 "ircd_parser.y"
5744	<	{
4711	>	#line 1646 "conf_parser.y"
4712	>	{
4713		if (conf_parser_ctx.pass == 2)
4714	<	{
5747	<	if (yylval.number)
5748	<	yy_aconf->flags |= CONF_FLAGS_EXEMPTKLINE;
5749	<	else
5750	<	yy_aconf->flags &= ~CONF_FLAGS_EXEMPTKLINE;
5751	<	}
4714	>	block_state.flags.value |= CONF_FLAGS_NO_TILDE;
4715		}
4716	+	#line 4717 "conf_parser.c"
4717		break;
4718
4719		case 325:
4720	<
4721	<	/* Line 1455 of yacc.c  */
5758	<	#line 2059 "ircd_parser.y"
5759	<	{
4720	>	#line 1650 "conf_parser.y"
4721	>	{
4722		if (conf_parser_ctx.pass == 2)
4723	<	{
5762	<	if (yylval.number)
5763	<	yy_aconf->flags |= CONF_FLAGS_NEED_IDENTD;
5764	<	else
5765	<	yy_aconf->flags &= ~CONF_FLAGS_NEED_IDENTD;
5766	<	}
4723	>	block_state.flags.value |= CONF_FLAGS_EXEMPTRESV;
4724		}
4725	+	#line 4726 "conf_parser.c"
4726		break;
4727
4728		case 326:
4729	<
4730	<	/* Line 1455 of yacc.c  */
5773	<	#line 2070 "ircd_parser.y"
5774	<	{
4729	>	#line 1654 "conf_parser.y"
4730	>	{
4731		if (conf_parser_ctx.pass == 2)
4732	<	{
5777	<	if (yylval.number)
5778	<	yy_aconf->flags |= CONF_FLAGS_NOLIMIT;
5779	<	else
5780	<	yy_aconf->flags &= ~CONF_FLAGS_NOLIMIT;
5781	<	}
4732	>	block_state.flags.value |= CONF_FLAGS_WEBIRC;
4733		}
4734	+	#line 4735 "conf_parser.c"
4735		break;
4736
4737		case 327:
4738	<
4739	<	/* Line 1455 of yacc.c  */
5788	<	#line 2081 "ircd_parser.y"
5789	<	{
4738	>	#line 1658 "conf_parser.y"
4739	>	{
4740		if (conf_parser_ctx.pass == 2)
4741	<	{
5792	<	if (yylval.number)
5793	<	yy_aconf->flags |= CONF_FLAGS_CAN_FLOOD;
5794	<	else
5795	<	yy_aconf->flags &= ~CONF_FLAGS_CAN_FLOOD;
5796	<	}
4741	>	block_state.flags.value |= CONF_FLAGS_NEED_PASSWORD;
4742		}
4743	+	#line 4744 "conf_parser.c"
4744		break;
4745
4746		case 328:
4747	+	#line 1664 "conf_parser.y"
4748	+	{
4749	+	if (conf_parser_ctx.pass != 2)
4750	+	break;
4751
4752	<	/* Line 1455 of yacc.c  */
5803	<	#line 2092 "ircd_parser.y"
5804	<	{
5805	<	if (conf_parser_ctx.pass == 2)
4752	>	if (valid_hostname(yylval.string))
4753		{
4754	<	if (yylval.number)
4755	<	yy_aconf->flags |= CONF_FLAGS_NO_TILDE;
5809	<	else
5810	<	yy_aconf->flags &= ~CONF_FLAGS_NO_TILDE;
4754	>	strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
4755	>	block_state.flags.value |= CONF_FLAGS_SPOOF_IP;
4756		}
4757	+	else
4758	+	ilog(LOG_TYPE_IRCD, "Spoof either is too long or contains invalid characters. Ignoring it.");
4759		}
4760	+	#line 4761 "conf_parser.c"
4761		break;
4762
4763		case 329:
4764	+	#line 1678 "conf_parser.y"
4765	+	{
4766	+	if (conf_parser_ctx.pass != 2)
4767	+	break;
4768
4769	<	/* Line 1455 of yacc.c  */
4770	<	#line 2103 "ircd_parser.y"
5819	<	{
5820	<	if (conf_parser_ctx.pass == 2)
5821	<	{
5822	<	if (yylval.number)
5823	<	yy_aconf->flags |= CONF_FLAGS_EXEMPTGLINE;
5824	<	else
5825	<	yy_aconf->flags &= ~CONF_FLAGS_EXEMPTGLINE;
5826	<	}
4769	>	strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
4770	>	block_state.flags.value |= CONF_FLAGS_REDIR;
4771		}
4772	+	#line 4773 "conf_parser.c"
4773		break;
4774
4775		case 330:
4776	+	#line 1687 "conf_parser.y"
4777	+	{
4778	+	if (conf_parser_ctx.pass != 2)
4779	+	break;
4780
4781	<	/* Line 1455 of yacc.c  */
4782	<	#line 2115 "ircd_parser.y"
5834	<	{
5835	<	if (conf_parser_ctx.pass == 2)
5836	<	{
5837	<	MyFree(yy_conf->name);
5838	<
5839	<	if (strlen(yylval.string) < HOSTLEN)
5840	<	{
5841	<	DupString(yy_conf->name, yylval.string);
5842	<	yy_aconf->flags |= CONF_FLAGS_SPOOF_IP;
5843	<	}
5844	<	else
5845	<	{
5846	<	ilog(L_ERROR, "Spoofs must be less than %d..ignoring it", HOSTLEN);
5847	<	yy_conf->name = NULL;
5848	<	}
5849	<	}
4781	>	block_state.flags.value |= CONF_FLAGS_REDIR;
4782	>	block_state.port.value = (yyvsp[-1].number);
4783		}
4784	+	#line 4785 "conf_parser.c"
4785		break;
4786
4787		case 331:
4788	+	#line 1700 "conf_parser.y"
4789	+	{
4790	+	if (conf_parser_ctx.pass != 2)
4791	+	break;
4792
4793	<	/* Line 1455 of yacc.c  */
4794	<	#line 2134 "ircd_parser.y"
5857	<	{
5858	<	if (conf_parser_ctx.pass == 2)
5859	<	{
5860	<	yy_aconf->flags |= CONF_FLAGS_REDIR;
5861	<	MyFree(yy_conf->name);
5862	<	DupString(yy_conf->name, yylval.string);
5863	<	}
4793	>	reset_block_state();
4794	>	strlcpy(block_state.rpass.buf, CONF_NOREASON, sizeof(block_state.rpass.buf));
4795		}
4796	+	#line 4797 "conf_parser.c"
4797		break;
4798
4799		case 332:
4800	<
4801	<	/* Line 1455 of yacc.c  */
4802	<	#line 2144 "ircd_parser.y"
5871	<	{
5872	<	if (conf_parser_ctx.pass == 2)
5873	<	{
5874	<	yy_aconf->flags |= CONF_FLAGS_REDIR;
5875	<	yy_aconf->port = (yyvsp[(3) - (4)].number);
5876	<	}
5877	<	}
4800	>	#line 1707 "conf_parser.y"
4801	>	{
4802	>	if (conf_parser_ctx.pass != 2)
4803		break;
4804
4805	<	case 333:
5881	<
5882	<	/* Line 1455 of yacc.c  */
5883	<	#line 2153 "ircd_parser.y"
5884	<	{
5885	<	if (conf_parser_ctx.pass == 2)
5886	<	{
5887	<	if (yylval.number)
5888	<	yy_aconf->flags |= CONF_FLAGS_NEED_PASSWORD;
5889	<	else
5890	<	yy_aconf->flags &= ~CONF_FLAGS_NEED_PASSWORD;
5891	<	}
4805	>	resv_make(block_state.name.buf, block_state.rpass.buf, &block_state.mask.list);
4806		}
4807	+	#line 4808 "conf_parser.c"
4808		break;
4809
4810	<	case 334:
4811	<
4812	<	/* Line 1455 of yacc.c  */
5898	<	#line 2168 "ircd_parser.y"
5899	<	{
4810	>	case 339:
4811	>	#line 1718 "conf_parser.y"
4812	>	{
4813		if (conf_parser_ctx.pass == 2)
4814	<	{
5902	<	MyFree(resv_reason);
5903	<	resv_reason = NULL;
5904	<	}
4814	>	strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
4815		}
4816	+	#line 4817 "conf_parser.c"
4817		break;
4818
4819	<	case 335:
4820	<
4821	<	/* Line 1455 of yacc.c  */
5911	<	#line 2175 "ircd_parser.y"
5912	<	{
4819	>	case 340:
4820	>	#line 1724 "conf_parser.y"
4821	>	{
4822		if (conf_parser_ctx.pass == 2)
4823	<	{
5915	<	MyFree(resv_reason);
5916	<	resv_reason = NULL;
5917	<	}
4823	>	strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
4824		}
4825	+	#line 4826 "conf_parser.c"
4826		break;
4827
4828	<	case 342:
4829	<
4830	<	/* Line 1455 of yacc.c  */
5924	<	#line 2187 "ircd_parser.y"
5925	<	{
4828	>	case 341:
4829	>	#line 1730 "conf_parser.y"
4830	>	{
4831		if (conf_parser_ctx.pass == 2)
4832	<	{
5928	<	MyFree(resv_reason);
5929	<	DupString(resv_reason, yylval.string);
5930	<	}
4832	>	dlinkAdd(xstrdup(yylval.string), make_dlink_node(), &block_state.mask.list);
4833		}
4834	+	#line 4835 "conf_parser.c"
4835		break;
4836
4837	<	case 343:
4837	>	case 347:
4838	>	#line 1745 "conf_parser.y"
4839	>	{
4840	>	if (conf_parser_ctx.pass != 2)
4841	>	break;
4842
4843	<	/* Line 1455 of yacc.c  */
5937	<	#line 2196 "ircd_parser.y"
5938	<	{
5939	<	if (conf_parser_ctx.pass == 2)
4843	>	if (server_valid_name(yylval.string) == true)
4844		{
4845	<	if (IsChanPrefix(*yylval.string))
4846	<	{
5943	<	char def_reason[] = "No reason";
5944	<
5945	<	create_channel_resv(yylval.string, resv_reason != NULL ? resv_reason : def_reason, 1);
5946	<	}
4845	>	struct ServiceItem *service = service_make();
4846	>	service->name = xstrdup(yylval.string);
4847		}
5948	–	/* ignore it for now.. but we really should make a warning if
5949	–	* its an erroneous name --fl_ */
4848		}
4849	+	#line 4850 "conf_parser.c"
4850		break;
4851
4852	<	case 344:
4853	<
4854	<	/* Line 1455 of yacc.c  */
4855	<	#line 2211 "ircd_parser.y"
5957	<	{
5958	<	if (conf_parser_ctx.pass == 2)
5959	<	{
5960	<	char def_reason[] = "No reason";
5961	<
5962	<	create_nick_resv(yylval.string, resv_reason != NULL ? resv_reason : def_reason, 1);
5963	<	}
5964	<	}
4852	>	case 348:
4853	>	#line 1761 "conf_parser.y"
4854	>	{
4855	>	if (conf_parser_ctx.pass != 2)
4856		break;
4857
4858	<	case 345:
4858	>	reset_block_state();
4859
4860	<	/* Line 1455 of yacc.c  */
4861	<	#line 2224 "ircd_parser.y"
4862	<	{
4863	<	if (conf_parser_ctx.pass == 2)
5973	<	{
5974	<	yy_conf = make_conf_item(ULINE_TYPE);
5975	<	yy_match_item = map_to_conf(yy_conf);
5976	<	yy_match_item->action = SHARED_ALL;
5977	<	}
4860	>	strlcpy(block_state.name.buf, "*", sizeof(block_state.name.buf));
4861	>	strlcpy(block_state.user.buf, "*", sizeof(block_state.user.buf));
4862	>	strlcpy(block_state.host.buf, "*", sizeof(block_state.host.buf));
4863	>	block_state.flags.value = SHARED_ALL;
4864		}
4865	+	#line 4866 "conf_parser.c"
4866		break;
4867
4868	<	case 346:
4868	>	case 349:
4869	>	#line 1772 "conf_parser.y"
4870	>	{
4871	>	if (conf_parser_ctx.pass != 2)
4872	>	break;
4873
4874	<	/* Line 1455 of yacc.c  */
4875	<	#line 2232 "ircd_parser.y"
4876	<	{
4877	<	if (conf_parser_ctx.pass == 2)
4878	<	{
5988	<	yy_conf = NULL;
5989	<	}
4874	>	struct SharedItem *shared = shared_make();
4875	>	shared->type = block_state.flags.value;
4876	>	shared->server = xstrdup(block_state.name.buf);
4877	>	shared->user = xstrdup(block_state.user.buf);
4878	>	shared->host = xstrdup(block_state.host.buf);
4879		}
4880	+	#line 4881 "conf_parser.c"
4881		break;
4882
4883	<	case 353:
4884	<
4885	<	/* Line 1455 of yacc.c  */
5996	<	#line 2243 "ircd_parser.y"
5997	<	{
4883	>	case 356:
4884	>	#line 1787 "conf_parser.y"
4885	>	{
4886		if (conf_parser_ctx.pass == 2)
4887	<	{
6000	<	MyFree(yy_conf->name);
6001	<	DupString(yy_conf->name, yylval.string);
6002	<	}
4887	>	strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
4888		}
4889	+	#line 4890 "conf_parser.c"
4890		break;
4891
4892	<	case 354:
4893	<
4894	<	/* Line 1455 of yacc.c  */
6009	<	#line 2252 "ircd_parser.y"
6010	<	{
4892	>	case 357:
4893	>	#line 1793 "conf_parser.y"
4894	>	{
4895		if (conf_parser_ctx.pass == 2)
4896		{
4897		struct split_nuh_item nuh;
4898
4899		nuh.nuhmask  = yylval.string;
4900		nuh.nickptr  = NULL;
4901	<	nuh.userptr  = userbuf;
4902	<	nuh.hostptr  = hostbuf;
4901	>	nuh.userptr  = block_state.user.buf;
4902	>	nuh.hostptr  = block_state.host.buf;
4903
4904		nuh.nicksize = 0;
4905	<	nuh.usersize = sizeof(userbuf);
4906	<	nuh.hostsize = sizeof(hostbuf);
4905	>	nuh.usersize = sizeof(block_state.user.buf);
4906	>	nuh.hostsize = sizeof(block_state.host.buf);
4907
4908		split_nuh(&nuh);
6025	–
6026	–	DupString(yy_match_item->user, userbuf);
6027	–	DupString(yy_match_item->host, hostbuf);
4909		}
4910		}
4911	+	#line 4912 "conf_parser.c"
4912		break;
4913
4914	<	case 355:
4915	<
4916	<	/* Line 1455 of yacc.c  */
6035	<	#line 2274 "ircd_parser.y"
6036	<	{
6037	<	if (conf_parser_ctx.pass == 2)
6038	<	yy_match_item->action = 0;
6039	<	}
6040	<	break;
6041	<
6042	<	case 359:
6043	<
6044	<	/* Line 1455 of yacc.c  */
6045	<	#line 2281 "ircd_parser.y"
6046	<	{
6047	<	if (conf_parser_ctx.pass == 2)
6048	<	yy_match_item->action |= SHARED_KLINE;
6049	<	}
6050	<	break;
6051	<
6052	<	case 360:
6053	<
6054	<	/* Line 1455 of yacc.c  */
6055	<	#line 2285 "ircd_parser.y"
6056	<	{
6057	<	if (conf_parser_ctx.pass == 2)
6058	<	yy_match_item->action |= SHARED_TKLINE;
6059	<	}
6060	<	break;
6061	<
6062	<	case 361:
6063	<
6064	<	/* Line 1455 of yacc.c  */
6065	<	#line 2289 "ircd_parser.y"
6066	<	{
4914	>	case 358:
4915	>	#line 1812 "conf_parser.y"
4916	>	{
4917		if (conf_parser_ctx.pass == 2)
4918	<	yy_match_item->action |= SHARED_UNKLINE;
4918	>	block_state.flags.value = 0;
4919		}
4920	+	#line 4921 "conf_parser.c"
4921		break;
4922
4923		case 362:
4924	<
4925	<	/* Line 1455 of yacc.c  */
6075	<	#line 2293 "ircd_parser.y"
6076	<	{
4924	>	#line 1819 "conf_parser.y"
4925	>	{
4926		if (conf_parser_ctx.pass == 2)
4927	<	yy_match_item->action |= SHARED_XLINE;
4927	>	block_state.flags.value |= SHARED_KLINE;
4928		}
4929	+	#line 4930 "conf_parser.c"
4930		break;
4931
4932		case 363:
4933	<
4934	<	/* Line 1455 of yacc.c  */
6085	<	#line 2297 "ircd_parser.y"
6086	<	{
4933	>	#line 1823 "conf_parser.y"
4934	>	{
4935		if (conf_parser_ctx.pass == 2)
4936	<	yy_match_item->action |= SHARED_TXLINE;
4936	>	block_state.flags.value |= SHARED_UNKLINE;
4937		}
4938	+	#line 4939 "conf_parser.c"
4939		break;
4940
4941		case 364:
4942	<
4943	<	/* Line 1455 of yacc.c  */
6095	<	#line 2301 "ircd_parser.y"
6096	<	{
4942	>	#line 1827 "conf_parser.y"
4943	>	{
4944		if (conf_parser_ctx.pass == 2)
4945	<	yy_match_item->action |= SHARED_UNXLINE;
4945	>	block_state.flags.value |= SHARED_DLINE;
4946		}
4947	+	#line 4948 "conf_parser.c"
4948		break;
4949
4950		case 365:
4951	<
4952	<	/* Line 1455 of yacc.c  */
6105	<	#line 2305 "ircd_parser.y"
6106	<	{
4951	>	#line 1831 "conf_parser.y"
4952	>	{
4953		if (conf_parser_ctx.pass == 2)
4954	<	yy_match_item->action |= SHARED_RESV;
4954	>	block_state.flags.value |= SHARED_UNDLINE;
4955		}
4956	+	#line 4957 "conf_parser.c"
4957		break;
4958
4959		case 366:
4960	<
4961	<	/* Line 1455 of yacc.c  */
6115	<	#line 2309 "ircd_parser.y"
6116	<	{
4960	>	#line 1835 "conf_parser.y"
4961	>	{
4962		if (conf_parser_ctx.pass == 2)
4963	<	yy_match_item->action |= SHARED_TRESV;
4963	>	block_state.flags.value |= SHARED_XLINE;
4964		}
4965	+	#line 4966 "conf_parser.c"
4966		break;
4967
4968		case 367:
4969	<
4970	<	/* Line 1455 of yacc.c  */
6125	<	#line 2313 "ircd_parser.y"
6126	<	{
4969	>	#line 1839 "conf_parser.y"
4970	>	{
4971		if (conf_parser_ctx.pass == 2)
4972	<	yy_match_item->action |= SHARED_UNRESV;
4972	>	block_state.flags.value |= SHARED_UNXLINE;
4973		}
4974	+	#line 4975 "conf_parser.c"
4975		break;
4976
4977		case 368:
4978	<
4979	<	/* Line 1455 of yacc.c  */
6135	<	#line 2317 "ircd_parser.y"
6136	<	{
4978	>	#line 1843 "conf_parser.y"
4979	>	{
4980		if (conf_parser_ctx.pass == 2)
4981	<	yy_match_item->action |= SHARED_LOCOPS;
4981	>	block_state.flags.value |= SHARED_RESV;
4982		}
4983	+	#line 4984 "conf_parser.c"
4984		break;
4985
4986		case 369:
4987	<
4988	<	/* Line 1455 of yacc.c  */
6145	<	#line 2321 "ircd_parser.y"
6146	<	{
4987	>	#line 1847 "conf_parser.y"
4988	>	{
4989		if (conf_parser_ctx.pass == 2)
4990	<	yy_match_item->action = SHARED_ALL;
4990	>	block_state.flags.value |= SHARED_UNRESV;
4991		}
4992	+	#line 4993 "conf_parser.c"
4993		break;
4994
4995		case 370:
4996	<
4997	<	/* Line 1455 of yacc.c  */
6155	<	#line 2330 "ircd_parser.y"
6156	<	{
4996	>	#line 1851 "conf_parser.y"
4997	>	{
4998		if (conf_parser_ctx.pass == 2)
4999	<	{
6159	<	yy_conf = make_conf_item(CLUSTER_TYPE);
6160	<	yy_conf->flags = SHARED_ALL;
6161	<	}
4999	>	block_state.flags.value |= SHARED_LOCOPS;
5000		}
5001	+	#line 5002 "conf_parser.c"
5002		break;
5003
5004		case 371:
5005	<
5006	<	/* Line 1455 of yacc.c  */
6168	<	#line 2337 "ircd_parser.y"
6169	<	{
5005	>	#line 1855 "conf_parser.y"
5006	>	{
5007		if (conf_parser_ctx.pass == 2)
5008	<	{
6172	<	if (yy_conf->name == NULL)
6173	<	DupString(yy_conf->name, "*");
6174	<	yy_conf = NULL;
6175	<	}
5008	>	block_state.flags.value = SHARED_ALL;
5009		}
5010	+	#line 5011 "conf_parser.c"
5011	+	break;
5012	+
5013	+	case 372:
5014	+	#line 1865 "conf_parser.y"
5015	+	{
5016	+	if (conf_parser_ctx.pass != 2)
5017		break;
5018
5019	<	case 377:
5019	>	reset_block_state();
5020
5021	<	/* Line 1455 of yacc.c  */
5022	<	#line 2350 "ircd_parser.y"
6183	<	{
6184	<	if (conf_parser_ctx.pass == 2)
6185	<	DupString(yy_conf->name, yylval.string);
5021	>	strlcpy(block_state.name.buf, "*", sizeof(block_state.name.buf));
5022	>	block_state.flags.value = CLUSTER_ALL;
5023		}
5024	+	#line 5025 "conf_parser.c"
5025		break;
5026
5027	<	case 378:
5027	>	case 373:
5028	>	#line 1874 "conf_parser.y"
5029	>	{
5030	>	if (conf_parser_ctx.pass != 2)
5031	>	break;
5032
5033	<	/* Line 1455 of yacc.c  */
5034	<	#line 2356 "ircd_parser.y"
5035	<	{
6194	<	if (conf_parser_ctx.pass == 2)
6195	<	yy_conf->flags = 0;
5033	>	struct ClusterItem *cluster = cluster_make();
5034	>	cluster->type = block_state.flags.value;
5035	>	cluster->server = xstrdup(block_state.name.buf);
5036		}
5037	+	#line 5038 "conf_parser.c"
5038		break;
5039
5040	<	case 382:
5041	<
5042	<	/* Line 1455 of yacc.c  */
6202	<	#line 2363 "ircd_parser.y"
6203	<	{
5040	>	case 379:
5041	>	#line 1887 "conf_parser.y"
5042	>	{
5043		if (conf_parser_ctx.pass == 2)
5044	<	yy_conf->flags |= SHARED_KLINE;
5044	>	strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
5045		}
5046	+	#line 5047 "conf_parser.c"
5047		break;
5048
5049	<	case 383:
5050	<
5051	<	/* Line 1455 of yacc.c  */
6212	<	#line 2367 "ircd_parser.y"
6213	<	{
5049	>	case 380:
5050	>	#line 1893 "conf_parser.y"
5051	>	{
5052		if (conf_parser_ctx.pass == 2)
5053	<	yy_conf->flags |= SHARED_TKLINE;
5053	>	block_state.flags.value = 0;
5054		}
5055	+	#line 5056 "conf_parser.c"
5056		break;
5057
5058		case 384:
5059	<
5060	<	/* Line 1455 of yacc.c  */
6222	<	#line 2371 "ircd_parser.y"
6223	<	{
5059	>	#line 1900 "conf_parser.y"
5060	>	{
5061		if (conf_parser_ctx.pass == 2)
5062	<	yy_conf->flags |= SHARED_UNKLINE;
5062	>	block_state.flags.value |= CLUSTER_KLINE;
5063		}
5064	+	#line 5065 "conf_parser.c"
5065		break;
5066
5067		case 385:
5068	<
5069	<	/* Line 1455 of yacc.c  */
6232	<	#line 2375 "ircd_parser.y"
6233	<	{
5068	>	#line 1904 "conf_parser.y"
5069	>	{
5070		if (conf_parser_ctx.pass == 2)
5071	<	yy_conf->flags |= SHARED_XLINE;
5071	>	block_state.flags.value |= CLUSTER_UNKLINE;
5072		}
5073	+	#line 5074 "conf_parser.c"
5074		break;
5075
5076		case 386:
5077	<
5078	<	/* Line 1455 of yacc.c  */
6242	<	#line 2379 "ircd_parser.y"
6243	<	{
5077	>	#line 1908 "conf_parser.y"
5078	>	{
5079		if (conf_parser_ctx.pass == 2)
5080	<	yy_conf->flags |= SHARED_TXLINE;
5080	>	block_state.flags.value |= CLUSTER_DLINE;
5081		}
5082	+	#line 5083 "conf_parser.c"
5083		break;
5084
5085		case 387:
5086	<
5087	<	/* Line 1455 of yacc.c  */
6252	<	#line 2383 "ircd_parser.y"
6253	<	{
5086	>	#line 1912 "conf_parser.y"
5087	>	{
5088		if (conf_parser_ctx.pass == 2)
5089	<	yy_conf->flags |= SHARED_UNXLINE;
5089	>	block_state.flags.value |= CLUSTER_UNDLINE;
5090		}
5091	+	#line 5092 "conf_parser.c"
5092		break;
5093
5094		case 388:
5095	<
5096	<	/* Line 1455 of yacc.c  */
6262	<	#line 2387 "ircd_parser.y"
6263	<	{
5095	>	#line 1916 "conf_parser.y"
5096	>	{
5097		if (conf_parser_ctx.pass == 2)
5098	<	yy_conf->flags |= SHARED_RESV;
5098	>	block_state.flags.value |= CLUSTER_XLINE;
5099		}
5100	+	#line 5101 "conf_parser.c"
5101		break;
5102
5103		case 389:
5104	<
5105	<	/* Line 1455 of yacc.c  */
6272	<	#line 2391 "ircd_parser.y"
6273	<	{
5104	>	#line 1920 "conf_parser.y"
5105	>	{
5106		if (conf_parser_ctx.pass == 2)
5107	<	yy_conf->flags |= SHARED_TRESV;
5107	>	block_state.flags.value |= CLUSTER_UNXLINE;
5108		}
5109	+	#line 5110 "conf_parser.c"
5110		break;
5111
5112		case 390:
5113	<
5114	<	/* Line 1455 of yacc.c  */
6282	<	#line 2395 "ircd_parser.y"
6283	<	{
5113	>	#line 1924 "conf_parser.y"
5114	>	{
5115		if (conf_parser_ctx.pass == 2)
5116	<	yy_conf->flags |= SHARED_UNRESV;
5116	>	block_state.flags.value |= CLUSTER_RESV;
5117		}
5118	+	#line 5119 "conf_parser.c"
5119		break;
5120
5121		case 391:
5122	<
5123	<	/* Line 1455 of yacc.c  */
6292	<	#line 2399 "ircd_parser.y"
6293	<	{
5122	>	#line 1928 "conf_parser.y"
5123	>	{
5124		if (conf_parser_ctx.pass == 2)
5125	<	yy_conf->flags |= SHARED_LOCOPS;
5125	>	block_state.flags.value |= CLUSTER_UNRESV;
5126		}
5127	+	#line 5128 "conf_parser.c"
5128		break;
5129
5130		case 392:
5131	<
5132	<	/* Line 1455 of yacc.c  */
6302	<	#line 2403 "ircd_parser.y"
6303	<	{
5131	>	#line 1932 "conf_parser.y"
5132	>	{
5133		if (conf_parser_ctx.pass == 2)
5134	<	yy_conf->flags = SHARED_ALL;
5134	>	block_state.flags.value |= CLUSTER_LOCOPS;
5135		}
5136	+	#line 5137 "conf_parser.c"
5137		break;
5138
5139		case 393:
5140	<
5141	<	/* Line 1455 of yacc.c  */
6312	<	#line 2412 "ircd_parser.y"
6313	<	{
5140	>	#line 1936 "conf_parser.y"
5141	>	{
5142		if (conf_parser_ctx.pass == 2)
5143	<	{
6316	<	yy_conf = make_conf_item(SERVER_TYPE);
6317	<	yy_aconf = (struct AccessItem *)map_to_conf(yy_conf);
6318	<	yy_aconf->passwd = NULL;
6319	<	/* defaults */
6320	<	yy_aconf->port = PORTNUM;
6321	<
6322	<	if (ConfigFileEntry.burst_away)
6323	<	yy_aconf->flags = CONF_FLAGS_BURST_AWAY;
6324	<	}
6325	<	else
6326	<	{
6327	<	MyFree(class_name);
6328	<	class_name = NULL;
6329	<	}
5143	>	block_state.flags.value = CLUSTER_ALL;
5144		}
5145	+	#line 5146 "conf_parser.c"
5146		break;
5147
5148		case 394:
5149	+	#line 1946 "conf_parser.y"
5150	+	{
5151
5152	<	/* Line 1455 of yacc.c  */
5153	<	#line 2430 "ircd_parser.y"
6337	<	{
6338	<	if (conf_parser_ctx.pass == 2)
6339	<	{
6340	<	struct CollectItem *yy_hconf=NULL;
6341	<	struct CollectItem *yy_lconf=NULL;
6342	<	dlink_node *ptr;
6343	<	dlink_node *next_ptr;
6344	<	#ifdef HAVE_LIBCRYPTO
6345	<	if (yy_aconf->host &&
6346	<	((yy_aconf->passwd && yy_aconf->spasswd) ||
6347	<	(yy_aconf->rsa_public_key && IsConfCryptLink(yy_aconf))))
6348	<	#else /* !HAVE_LIBCRYPTO */
6349	<	if (yy_aconf->host && !IsConfCryptLink(yy_aconf) &&
6350	<	yy_aconf->passwd && yy_aconf->spasswd)
6351	<	#endif /* !HAVE_LIBCRYPTO */
6352	<	{
6353	<	if (conf_add_server(yy_conf, class_name) == -1)
6354	<	{
6355	<	delete_conf_item(yy_conf);
6356	<	yy_conf = NULL;
6357	<	yy_aconf = NULL;
6358	<	}
6359	<	}
6360	<	else
6361	<	{
6362	<	/* Even if yy_conf ->name is NULL
6363	<	* should still unhook any hub/leaf confs still pending
6364	<	*/
6365	<	unhook_hub_leaf_confs();
6366	<
6367	<	if (yy_conf->name != NULL)
6368	<	{
6369	<	#ifndef HAVE_LIBCRYPTO
6370	<	if (IsConfCryptLink(yy_aconf))
6371	<	yyerror("Ignoring connect block -- no OpenSSL support");
6372	<	#else
6373	<	if (IsConfCryptLink(yy_aconf) && !yy_aconf->rsa_public_key)
6374	<	yyerror("Ignoring connect block -- missing key");
6375	<	#endif
6376	<	if (yy_aconf->host == NULL)
6377	<	yyerror("Ignoring connect block -- missing host");
6378	<	else if (!IsConfCryptLink(yy_aconf) &&
6379	<	(!yy_aconf->passwd || !yy_aconf->spasswd))
6380	<	yyerror("Ignoring connect block -- missing password");
6381	<	}
6382	<
6383	<
6384	<	/* XXX
6385	<	* This fixes a try_connections() core (caused by invalid class_ptr
6386	<	* pointers) reported by metalrock. That's an ugly fix, but there
6387	<	* is currently no better way. The entire config subsystem needs an
6388	<	* rewrite ASAP. make_conf_item() shouldn't really add things onto
6389	<	* a doubly linked list immediately without any sanity checks!  -Michael
6390	<	*/
6391	<	delete_conf_item(yy_conf);
6392	<
6393	<	yy_aconf = NULL;
6394	<	yy_conf = NULL;
6395	<	}
6396	<
6397	<	/*
6398	<	* yy_conf is still pointing at the server that is having
6399	<	* a connect block built for it. This means, y_aconf->name
6400	<	* points to the actual irc name this server will be known as.
6401	<	* Now this new server has a set or even just one hub_mask (or leaf_mask)
6402	<	* given in the link list at yy_hconf. Fill in the HUB confs
6403	<	* from this link list now.
6404	<	*/
6405	<	DLINK_FOREACH_SAFE(ptr, next_ptr, hub_conf_list.head)
6406	<	{
6407	<	struct ConfItem *new_hub_conf;
6408	<	struct MatchItem *match_item;
6409	<
6410	<	yy_hconf = ptr->data;
6411	<
6412	<	/* yy_conf == NULL is a fatal error for this connect block! */
6413	<	if ((yy_conf != NULL) && (yy_conf->name != NULL))
6414	<	{
6415	<	new_hub_conf = make_conf_item(HUB_TYPE);
6416	<	match_item = (struct MatchItem *)map_to_conf(new_hub_conf);
6417	<	DupString(new_hub_conf->name, yy_conf->name);
6418	<	if (yy_hconf->user != NULL)
6419	<	DupString(match_item->user, yy_hconf->user);
6420	<	else
6421	<	DupString(match_item->user, "*");
6422	<	if (yy_hconf->host != NULL)
6423	<	DupString(match_item->host, yy_hconf->host);
6424	<	else
6425	<	DupString(match_item->host, "*");
6426	<	}
6427	<	dlinkDelete(&yy_hconf->node, &hub_conf_list);
6428	<	free_collect_item(yy_hconf);
6429	<	}
6430	<
6431	<	/* Ditto for the LEAF confs */
6432	<
6433	<	DLINK_FOREACH_SAFE(ptr, next_ptr, leaf_conf_list.head)
6434	<	{
6435	<	struct ConfItem *new_leaf_conf;
6436	<	struct MatchItem *match_item;
6437	<
6438	<	yy_lconf = ptr->data;
5152	>	if (conf_parser_ctx.pass != 2)
5153	>	break;
5154
5155	<	if ((yy_conf != NULL) && (yy_conf->name != NULL))
5156	<	{
5157	<	new_leaf_conf = make_conf_item(LEAF_TYPE);
5158	<	match_item = (struct MatchItem *)map_to_conf(new_leaf_conf);
6444	<	DupString(new_leaf_conf->name, yy_conf->name);
6445	<	if (yy_lconf->user != NULL)
6446	<	DupString(match_item->user, yy_lconf->user);
6447	<	else
6448	<	DupString(match_item->user, "*");
6449	<	if (yy_lconf->host != NULL)
6450	<	DupString(match_item->host, yy_lconf->host);
6451	<	else
6452	<	DupString(match_item->host, "*");
6453	<	}
6454	<	dlinkDelete(&yy_lconf->node, &leaf_conf_list);
6455	<	free_collect_item(yy_lconf);
6456	<	}
6457	<	MyFree(class_name);
6458	<	class_name = NULL;
6459	<	yy_conf = NULL;
6460	<	yy_aconf = NULL;
6461	<	}
5155	>	reset_block_state();
5156	>	block_state.aftype.value = AF_INET;
5157	>	block_state.port.value = PORTNUM;
5158	>	block_state.timeout.value = CONNECTTIMEOUT;
5159		}
5160	+	#line 5161 "conf_parser.c"
5161		break;
5162
5163	<	case 419:
5163	>	case 395:
5164	>	#line 1956 "conf_parser.y"
5165	>	{
5166	>	struct addrinfo hints, *res;
5167
5168	<	/* Line 1455 of yacc.c  */
5169	<	#line 2569 "ircd_parser.y"
6469	<	{
6470	<	if (conf_parser_ctx.pass == 2)
6471	<	{
6472	<	if (yy_conf->name != NULL)
6473	<	yyerror("Multiple connect name entry");
5168	>	if (conf_parser_ctx.pass != 2)
5169	>	break;
5170
5171	<	MyFree(yy_conf->name);
5172	<	DupString(yy_conf->name, yylval.string);
6477	<	}
6478	<	}
5171	>	if (!block_state.name.buf[0] ||
5172	>	!block_state.host.buf[0])
5173		break;
5174
5175	<	case 420:
5175	>	if (!block_state.rpass.buf[0] ||
5176	>	!block_state.spass.buf[0])
5177	>	break;
5178
5179	<	/* Line 1455 of yacc.c  */
5180	<	#line 2581 "ircd_parser.y"
6485	<	{
6486	<	if (conf_parser_ctx.pass == 2)
6487	<	{
6488	<	if (yy_conf->name != NULL)
6489	<	yyerror("Multiple connect name entry");
5179	>	if (server_valid_name(block_state.name.buf) == false)
5180	>	break;
5181
5182	<	MyFree(yy_conf->name);
5183	<	DupString(yy_conf->name, yylval.string);
6493	<	}
6494	<	}
5182	>	if (has_wildcards(block_state.name.buf) ||
5183	>	has_wildcards(block_state.host.buf))
5184		break;
5185
5186	<	case 421:
5186	>	struct MaskItem *conf = conf_make(CONF_SERVER);
5187	>	conf->addr = xcalloc(sizeof(*conf->addr));
5188	>	conf->port = block_state.port.value;
5189	>	conf->timeout = block_state.timeout.value;
5190	>	conf->flags = block_state.flags.value;
5191	>	conf->aftype = block_state.aftype.value;
5192	>	conf->host = xstrdup(block_state.host.buf);
5193	>	conf->name = xstrdup(block_state.name.buf);
5194	>	conf->passwd = xstrdup(block_state.rpass.buf);
5195	>	conf->spasswd = xstrdup(block_state.spass.buf);
5196
5197	<	/* Line 1455 of yacc.c  */
5198	<	#line 2593 "ircd_parser.y"
6501	<	{
6502	<	if (conf_parser_ctx.pass == 2)
6503	<	{
6504	<	MyFree(yy_aconf->host);
6505	<	DupString(yy_aconf->host, yylval.string);
6506	<	}
6507	<	}
6508	<	break;
5197	>	if (block_state.cert.buf[0])
5198	>	conf->certfp = xstrdup(block_state.cert.buf);
5199
5200	<	case 422:
5200	>	if (block_state.ciph.buf[0])
5201	>	conf->cipher_list = xstrdup(block_state.ciph.buf);
5202
5203	<	/* Line 1455 of yacc.c  */
5204	<	#line 2602 "ircd_parser.y"
6514	<	{
6515	<	if (conf_parser_ctx.pass == 2)
6516	<	{
6517	<	struct addrinfo hints, *res;
5203	>	dlinkMoveList(&block_state.leaf.list, &conf->leaf_list);
5204	>	dlinkMoveList(&block_state.hub.list, &conf->hub_list);
5205
5206	+	if (block_state.bind.buf[0])
5207	+	{
5208		memset(&hints, 0, sizeof(hints));
5209
5210		hints.ai_family   = AF_UNSPEC;
5211		hints.ai_socktype = SOCK_STREAM;
5212		hints.ai_flags    = AI_PASSIVE | AI_NUMERICHOST;
5213
5214	<	if (irc_getaddrinfo(yylval.string, NULL, &hints, &res))
5215	<	ilog(L_ERROR, "Invalid netmask for server vhost(%s)", yylval.string);
5214	>	if (getaddrinfo(block_state.bind.buf, NULL, &hints, &res))
5215	>	ilog(LOG_TYPE_IRCD, "Invalid netmask for server bind(%s)", block_state.bind.buf);
5216		else
5217		{
5218	<	assert(res != NULL);
5218	>	assert(res);
5219
5220	<	memcpy(&yy_aconf->my_ipnum, res->ai_addr, res->ai_addrlen);
6532	<	yy_aconf->my_ipnum.ss.ss_family = res->ai_family;
6533	<	yy_aconf->my_ipnum.ss_len = res->ai_addrlen;
6534	<	irc_freeaddrinfo(res);
6535	<	}
6536	<	}
6537	<	}
6538	<	break;
5220	>	conf->bind = xcalloc(sizeof(*conf->bind));
5221
5222	<	case 423:
5223	<
5224	<	/* Line 1455 of yacc.c  */
6543	<	#line 2628 "ircd_parser.y"
6544	<	{
6545	<	if (conf_parser_ctx.pass == 2)
6546	<	{
6547	<	if ((yyvsp[(3) - (4)].string)[0] == ':')
6548	<	yyerror("Server passwords cannot begin with a colon");
6549	<	else if (strchr((yyvsp[(3) - (4)].string), ' ') != NULL)
6550	<	yyerror("Server passwords cannot contain spaces");
6551	<	else {
6552	<	if (yy_aconf->spasswd != NULL)
6553	<	memset(yy_aconf->spasswd, 0, strlen(yy_aconf->spasswd));
6554	<
6555	<	MyFree(yy_aconf->spasswd);
6556	<	DupString(yy_aconf->spasswd, yylval.string);
5222	>	memcpy(conf->bind, res->ai_addr, res->ai_addrlen);
5223	>	conf->bind->ss_len = res->ai_addrlen;
5224	>	freeaddrinfo(res);
5225		}
5226		}
6559	–	}
6560	–	break;
6561	–
6562	–	case 424:
5227
5228	<	/* Line 1455 of yacc.c  */
5229	<	#line 2646 "ircd_parser.y"
6566	<	{
6567	<	if (conf_parser_ctx.pass == 2)
6568	<	{
6569	<	if ((yyvsp[(3) - (4)].string)[0] == ':')
6570	<	yyerror("Server passwords cannot begin with a colon");
6571	<	else if (strchr((yyvsp[(3) - (4)].string), ' ') != NULL)
6572	<	yyerror("Server passwords cannot contain spaces");
6573	<	else {
6574	<	if (yy_aconf->passwd != NULL)
6575	<	memset(yy_aconf->passwd, 0, strlen(yy_aconf->passwd));
6576	<
6577	<	MyFree(yy_aconf->passwd);
6578	<	DupString(yy_aconf->passwd, yylval.string);
6579	<	}
6580	<	}
5228	>	conf_add_class_to_conf(conf, block_state.class.buf);
5229	>	conf_dns_lookup(conf);
5230		}
5231	+	#line 5232 "conf_parser.c"
5232		break;
5233
5234	<	case 425:
5235	<
5236	<	/* Line 1455 of yacc.c  */
6587	<	#line 2664 "ircd_parser.y"
6588	<	{
5234	>	case 414:
5235	>	#line 2042 "conf_parser.y"
5236	>	{
5237		if (conf_parser_ctx.pass == 2)
5238	<	yy_aconf->port = (yyvsp[(3) - (4)].number);
5238	>	strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
5239		}
5240	+	#line 5241 "conf_parser.c"
5241		break;
5242
5243	<	case 426:
5244	<
5245	<	/* Line 1455 of yacc.c  */
6597	<	#line 2670 "ircd_parser.y"
6598	<	{
5243	>	case 415:
5244	>	#line 2048 "conf_parser.y"
5245	>	{
5246		if (conf_parser_ctx.pass == 2)
5247	<	yy_aconf->aftype = AF_INET;
5247	>	strlcpy(block_state.host.buf, yylval.string, sizeof(block_state.host.buf));
5248		}
5249	+	#line 5250 "conf_parser.c"
5250		break;
5251
5252	<	case 427:
5253	<
5254	<	/* Line 1455 of yacc.c  */
6607	<	#line 2674 "ircd_parser.y"
6608	<	{
6609	<	#ifdef IPV6
5252	>	case 416:
5253	>	#line 2054 "conf_parser.y"
5254	>	{
5255		if (conf_parser_ctx.pass == 2)
5256	<	yy_aconf->aftype = AF_INET6;
6612	<	#endif
5256	>	block_state.timeout.value = (yyvsp[-1].number);
5257		}
5258	+	#line 5259 "conf_parser.c"
5259		break;
5260
5261	<	case 428:
5262	<
5263	<	/* Line 1455 of yacc.c  */
6619	<	#line 2682 "ircd_parser.y"
6620	<	{
5261	>	case 417:
5262	>	#line 2060 "conf_parser.y"
5263	>	{
5264		if (conf_parser_ctx.pass == 2)
5265	<	{
6623	<	MyFree(yy_aconf->fakename);
6624	<	DupString(yy_aconf->fakename, yylval.string);
6625	<	}
5265	>	strlcpy(block_state.bind.buf, yylval.string, sizeof(block_state.bind.buf));
5266		}
5267	+	#line 5268 "conf_parser.c"
5268		break;
5269
5270	<	case 429:
5271	<
5272	<	/* Line 1455 of yacc.c  */
5273	<	#line 2691 "ircd_parser.y"
6633	<	{
6634	<	}
6635	<	break;
6636	<
6637	<	case 433:
6638	<
6639	<	/* Line 1455 of yacc.c  */
6640	<	#line 2695 "ircd_parser.y"
6641	<	{ not_atom = 1; }
6642	<	break;
6643	<
6644	<	case 435:
6645	<
6646	<	/* Line 1455 of yacc.c  */
6647	<	#line 2696 "ircd_parser.y"
6648	<	{ not_atom = 0; }
5270	>	case 418:
5271	>	#line 2066 "conf_parser.y"
5272	>	{
5273	>	if (conf_parser_ctx.pass != 2)
5274		break;
5275
5276	<	case 437:
5277	<
5278	<	/* Line 1455 of yacc.c  */
5279	<	#line 2699 "ircd_parser.y"
5280	<	{
5281	<	if (conf_parser_ctx.pass == 2)
6657	<	#ifndef HAVE_LIBZ
6658	<	yyerror("Ignoring flags = compressed; -- no zlib support");
6659	<	#else
6660	<	{
6661	<	if (not_atom)ClearConfCompressed(yy_aconf);
6662	<	else SetConfCompressed(yy_aconf);
6663	<	}
6664	<	#endif
5276	>	if (*yylval.string == ':')
5277	>	conf_error_report("Server passwords cannot begin with a colon");
5278	>	else if (strchr(yylval.string, ' '))
5279	>	conf_error_report("Server passwords cannot contain spaces");
5280	>	else
5281	>	strlcpy(block_state.spass.buf, yylval.string, sizeof(block_state.spass.buf));
5282		}
5283	+	#line 5284 "conf_parser.c"
5284		break;
5285
5286	<	case 438:
5287	<
5288	<	/* Line 1455 of yacc.c  */
5289	<	#line 2710 "ircd_parser.y"
6672	<	{
6673	<	if (conf_parser_ctx.pass == 2)
6674	<	{
6675	<	if (not_atom)ClearConfCryptLink(yy_aconf);
6676	<	else SetConfCryptLink(yy_aconf);
6677	<	}
6678	<	}
5286	>	case 419:
5287	>	#line 2079 "conf_parser.y"
5288	>	{
5289	>	if (conf_parser_ctx.pass != 2)
5290		break;
5291
5292	<	case 439:
5293	<
5294	<	/* Line 1455 of yacc.c  */
5295	<	#line 2717 "ircd_parser.y"
5296	<	{
5297	<	if (conf_parser_ctx.pass == 2)
6687	<	{
6688	<	if (not_atom)ClearConfAllowAutoConn(yy_aconf);
6689	<	else SetConfAllowAutoConn(yy_aconf);
6690	<	}
5292	>	if (*yylval.string == ':')
5293	>	conf_error_report("Server passwords cannot begin with a colon");
5294	>	else if (strchr(yylval.string, ' '))
5295	>	conf_error_report("Server passwords cannot contain spaces");
5296	>	else
5297	>	strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
5298		}
5299	+	#line 5300 "conf_parser.c"
5300		break;
5301
5302	<	case 440:
5303	<
5304	<	/* Line 1455 of yacc.c  */
6697	<	#line 2724 "ircd_parser.y"
6698	<	{
5302	>	case 420:
5303	>	#line 2092 "conf_parser.y"
5304	>	{
5305		if (conf_parser_ctx.pass == 2)
5306	<	{
6701	<	if (not_atom)ClearConfAwayBurst(yy_aconf);
6702	<	else SetConfAwayBurst(yy_aconf);
6703	<	}
5306	>	strlcpy(block_state.cert.buf, yylval.string, sizeof(block_state.cert.buf));
5307		}
5308	+	#line 5309 "conf_parser.c"
5309		break;
5310
5311	<	case 441:
5312	<
5313	<	/* Line 1455 of yacc.c  */
6710	<	#line 2731 "ircd_parser.y"
6711	<	{
5311	>	case 421:
5312	>	#line 2098 "conf_parser.y"
5313	>	{
5314		if (conf_parser_ctx.pass == 2)
5315	<	{
6714	<	if (not_atom)ClearConfTopicBurst(yy_aconf);
6715	<	else SetConfTopicBurst(yy_aconf);
6716	<	}
5315	>	block_state.port.value = (yyvsp[-1].number);
5316		}
5317	+	#line 5318 "conf_parser.c"
5318		break;
5319
5320	<	case 442:
5321	<
5322	<	/* Line 1455 of yacc.c  */
6723	<	#line 2741 "ircd_parser.y"
6724	<	{
6725	<	#ifdef HAVE_LIBCRYPTO
5320	>	case 422:
5321	>	#line 2104 "conf_parser.y"
5322	>	{
5323		if (conf_parser_ctx.pass == 2)
5324	<	{
6728	<	BIO *file;
6729	<
6730	<	if (yy_aconf->rsa_public_key != NULL)
6731	<	{
6732	<	RSA_free(yy_aconf->rsa_public_key);
6733	<	yy_aconf->rsa_public_key = NULL;
6734	<	}
6735	<
6736	<	if (yy_aconf->rsa_public_key_file != NULL)
6737	<	{
6738	<	MyFree(yy_aconf->rsa_public_key_file);
6739	<	yy_aconf->rsa_public_key_file = NULL;
6740	<	}
6741	<
6742	<	DupString(yy_aconf->rsa_public_key_file, yylval.string);
6743	<
6744	<	if ((file = BIO_new_file(yylval.string, "r")) == NULL)
6745	<	{
6746	<	yyerror("Ignoring rsa_public_key_file -- file doesn't exist");
6747	<	break;
6748	<	}
6749	<
6750	<	yy_aconf->rsa_public_key = (RSA *)PEM_read_bio_RSA_PUBKEY(file, NULL, 0, NULL);
6751	<
6752	<	if (yy_aconf->rsa_public_key == NULL)
6753	<	{
6754	<	yyerror("Ignoring rsa_public_key_file -- Key invalid; check key syntax.");
6755	<	break;
6756	<	}
6757	<
6758	<	BIO_set_close(file, BIO_CLOSE);
6759	<	BIO_free(file);
6760	<	}
6761	<	#endif /* HAVE_LIBCRYPTO */
5324	>	block_state.aftype.value = AF_INET;
5325		}
5326	+	#line 5327 "conf_parser.c"
5327		break;
5328
5329	<	case 443:
5330	<
5331	<	/* Line 1455 of yacc.c  */
6768	<	#line 2782 "ircd_parser.y"
6769	<	{
5329	>	case 423:
5330	>	#line 2108 "conf_parser.y"
5331	>	{
5332		if (conf_parser_ctx.pass == 2)
5333	<	{
6772	<	if (yylval.number)
6773	<	yy_aconf->flags |= CONF_FLAGS_ENCRYPTED;
6774	<	else
6775	<	yy_aconf->flags &= ~CONF_FLAGS_ENCRYPTED;
6776	<	}
5333	>	block_state.aftype.value = AF_INET6;
5334		}
5335	+	#line 5336 "conf_parser.c"
5336		break;
5337
5338	<	case 444:
5339	<
5340	<	/* Line 1455 of yacc.c  */
5341	<	#line 2793 "ircd_parser.y"
6784	<	{
6785	<	if (conf_parser_ctx.pass == 2)
6786	<	{
6787	<	if (yylval.number)
6788	<	yy_aconf->flags |= CONF_FLAGS_CRYPTLINK;
6789	<	else
6790	<	yy_aconf->flags &= ~CONF_FLAGS_CRYPTLINK;
6791	<	}
5338	>	case 424:
5339	>	#line 2114 "conf_parser.y"
5340	>	{
5341	>	block_state.flags.value &= CONF_FLAGS_ENCRYPTED;
5342		}
5343	+	#line 5344 "conf_parser.c"
5344		break;
5345
5346	<	case 445:
5347	<
5348	<	/* Line 1455 of yacc.c  */
6798	<	#line 2804 "ircd_parser.y"
6799	<	{
5346	>	case 428:
5347	>	#line 2120 "conf_parser.y"
5348	>	{
5349		if (conf_parser_ctx.pass == 2)
5350	<	{
6802	<	if (yylval.number)
6803	<	#ifndef HAVE_LIBZ
6804	<	yyerror("Ignoring compressed=yes; -- no zlib support");
6805	<	#else
6806	<	yy_aconf->flags |= CONF_FLAGS_COMPRESSED;
6807	<	#endif
6808	<	else
6809	<	yy_aconf->flags &= ~CONF_FLAGS_COMPRESSED;
6810	<	}
5350	>	block_state.flags.value |= CONF_FLAGS_ALLOW_AUTO_CONN;
5351		}
5352	+	#line 5353 "conf_parser.c"
5353		break;
5354
5355	<	case 446:
5356	<
5357	<	/* Line 1455 of yacc.c  */
6817	<	#line 2819 "ircd_parser.y"
6818	<	{
5355	>	case 429:
5356	>	#line 2124 "conf_parser.y"
5357	>	{
5358		if (conf_parser_ctx.pass == 2)
5359	<	{
6821	<	if (yylval.number)
6822	<	yy_aconf->flags |= CONF_FLAGS_ALLOW_AUTO_CONN;
6823	<	else
6824	<	yy_aconf->flags &= ~CONF_FLAGS_ALLOW_AUTO_CONN;
6825	<	}
5359	>	block_state.flags.value |= CONF_FLAGS_TLS;
5360		}
5361	+	#line 5362 "conf_parser.c"
5362		break;
5363
5364	<	case 447:
5365	<
5366	<	/* Line 1455 of yacc.c  */
6832	<	#line 2830 "ircd_parser.y"
6833	<	{
5364	>	case 430:
5365	>	#line 2130 "conf_parser.y"
5366	>	{
5367		if (conf_parser_ctx.pass == 2)
5368		{
5369		if (yylval.number)
5370	<	SetConfTopicBurst(yy_aconf);
5370	>	block_state.flags.value |= CONF_FLAGS_ENCRYPTED;
5371		else
5372	<	ClearConfTopicBurst(yy_aconf);
5372	>	block_state.flags.value &= ~CONF_FLAGS_ENCRYPTED;
5373		}
5374		}
5375	+	#line 5376 "conf_parser.c"
5376		break;
5377
5378	<	case 448:
5379	<
5380	<	/* Line 1455 of yacc.c  */
6847	<	#line 2841 "ircd_parser.y"
6848	<	{
5378	>	case 431:
5379	>	#line 2141 "conf_parser.y"
5380	>	{
5381		if (conf_parser_ctx.pass == 2)
5382	<	{
6851	<	struct CollectItem *yy_tmp;
6852	<
6853	<	yy_tmp = (struct CollectItem *)MyMalloc(sizeof(struct CollectItem));
6854	<	DupString(yy_tmp->host, yylval.string);
6855	<	DupString(yy_tmp->user, "*");
6856	<	dlinkAdd(yy_tmp, &yy_tmp->node, &hub_conf_list);
6857	<	}
5382	>	dlinkAdd(xstrdup(yylval.string), make_dlink_node(), &block_state.hub.list);
5383		}
5384	+	#line 5385 "conf_parser.c"
5385		break;
5386
5387	<	case 449:
5388	<
5389	<	/* Line 1455 of yacc.c  */
6864	<	#line 2854 "ircd_parser.y"
6865	<	{
5387	>	case 432:
5388	>	#line 2147 "conf_parser.y"
5389	>	{
5390		if (conf_parser_ctx.pass == 2)
5391	<	{
6868	<	struct CollectItem *yy_tmp;
6869	<
6870	<	yy_tmp = (struct CollectItem *)MyMalloc(sizeof(struct CollectItem));
6871	<	DupString(yy_tmp->host, yylval.string);
6872	<	DupString(yy_tmp->user, "*");
6873	<	dlinkAdd(yy_tmp, &yy_tmp->node, &leaf_conf_list);
6874	<	}
5391	>	dlinkAdd(xstrdup(yylval.string), make_dlink_node(), &block_state.leaf.list);
5392		}
5393	+	#line 5394 "conf_parser.c"
5394		break;
5395
5396	<	case 450:
5397	<
5398	<	/* Line 1455 of yacc.c  */
6881	<	#line 2867 "ircd_parser.y"
6882	<	{
5396	>	case 433:
5397	>	#line 2153 "conf_parser.y"
5398	>	{
5399		if (conf_parser_ctx.pass == 2)
5400	<	{
6885	<	MyFree(class_name);
6886	<	DupString(class_name, yylval.string);
6887	<	}
5400	>	strlcpy(block_state.class.buf, yylval.string, sizeof(block_state.class.buf));
5401		}
5402	+	#line 5403 "conf_parser.c"
5403		break;
5404
5405	<	case 451:
5406	<
5407	<	/* Line 1455 of yacc.c  */
5408	<	#line 2876 "ircd_parser.y"
6895	<	{
6896	<	#ifdef HAVE_LIBCRYPTO
5405	>	case 434:
5406	>	#line 2159 "conf_parser.y"
5407	>	{
5408	>	#ifdef HAVE_TLS
5409		if (conf_parser_ctx.pass == 2)
5410	<	{
6899	<	struct EncCapability *ecap;
6900	<	const char *cipher_name;
6901	<	int found = 0;
6902	<
6903	<	yy_aconf->cipher_preference = NULL;
6904	<	cipher_name = yylval.string;
6905	<
6906	<	for (ecap = CipherTable; ecap->name; ecap++)
6907	<	{
6908	<	if ((irccmp(ecap->name, cipher_name) == 0) &&
6909	<	(ecap->cap & CAP_ENC_MASK))
6910	<	{
6911	<	yy_aconf->cipher_preference = ecap;
6912	<	found = 1;
6913	<	break;
6914	<	}
6915	<	}
6916	<
6917	<	if (!found)
6918	<	yyerror("Invalid cipher");
6919	<	}
5410	>	strlcpy(block_state.ciph.buf, yylval.string, sizeof(block_state.ciph.buf));
5411		#else
5412		if (conf_parser_ctx.pass == 2)
5413	<	yyerror("Ignoring cipher_preference -- no OpenSSL support");
5413	>	conf_error_report("Ignoring connect::tls_cipher_list -- no TLS support");
5414		#endif
5415		}
5416	+	#line 5417 "conf_parser.c"
5417		break;
5418
5419	<	case 452:
5420	<
5421	<	/* Line 1455 of yacc.c  */
6930	<	#line 2911 "ircd_parser.y"
6931	<	{
5419	>	case 435:
5420	>	#line 2174 "conf_parser.y"
5421	>	{
5422		if (conf_parser_ctx.pass == 2)
5423	<	{
6934	<	userbuf[0] = hostbuf[0] = reasonbuf[0] = '\0';
6935	<	regex_ban = 0;
6936	<	}
5423	>	reset_block_state();
5424		}
5425	+	#line 5426 "conf_parser.c"
5426		break;
5427
5428	<	case 453:
5429	<
5430	<	/* Line 1455 of yacc.c  */
5431	<	#line 2918 "ircd_parser.y"
6944	<	{
6945	<	if (conf_parser_ctx.pass == 2)
6946	<	{
6947	<	if (userbuf[0] && hostbuf[0])
6948	<	{
6949	<	if (regex_ban)
6950	<	{
6951	<	#ifdef HAVE_LIBPCRE
6952	<	void *exp_user = NULL;
6953	<	void *exp_host = NULL;
6954	<	const char *errptr = NULL;
6955	<
6956	<	if (!(exp_user = ircd_pcre_compile(userbuf, &errptr)) ||
6957	<	!(exp_host = ircd_pcre_compile(hostbuf, &errptr)))
6958	<	{
6959	<	ilog(L_ERROR, "Failed to add regular expression based K-Line: %s",
6960	<	errptr);
6961	<	break;
6962	<	}
6963	<
6964	<	yy_aconf = map_to_conf(make_conf_item(RKLINE_TYPE));
6965	<	yy_aconf->regexuser = exp_user;
6966	<	yy_aconf->regexhost = exp_host;
6967	<
6968	<	DupString(yy_aconf->user, userbuf);
6969	<	DupString(yy_aconf->host, hostbuf);
6970	<
6971	<	if (reasonbuf[0])
6972	<	DupString(yy_aconf->reason, reasonbuf);
6973	<	else
6974	<	DupString(yy_aconf->reason, "No reason");
6975	<	#else
6976	<	ilog(L_ERROR, "Failed to add regular expression based K-Line: no PCRE support");
6977	<	break;
6978	<	#endif
6979	<	}
6980	<	else
6981	<	{
6982	<	yy_aconf = map_to_conf(make_conf_item(KLINE_TYPE));
6983	<
6984	<	DupString(yy_aconf->user, userbuf);
6985	<	DupString(yy_aconf->host, hostbuf);
6986	<
6987	<	if (reasonbuf[0])
6988	<	DupString(yy_aconf->reason, reasonbuf);
6989	<	else
6990	<	DupString(yy_aconf->reason, "No reason");
6991	<	add_conf_by_address(CONF_KILL, yy_aconf);
6992	<	}
6993	<	}
6994	<
6995	<	yy_aconf = NULL;
6996	<	}
6997	<	}
5428	>	case 436:
5429	>	#line 2178 "conf_parser.y"
5430	>	{
5431	>	if (conf_parser_ctx.pass != 2)
5432		break;
5433
5434	<	case 454:
5435	<
7002	<	/* Line 1455 of yacc.c  */
7003	<	#line 2974 "ircd_parser.y"
7004	<	{
7005	<	}
5434	>	if (!block_state.user.buf[0] ||
5435	>	!block_state.host.buf[0])
5436		break;
5437
5438	<	case 458:
5438	>	struct MaskItem *conf = conf_make(CONF_KLINE);
5439	>	conf->user = xstrdup(block_state.user.buf);
5440	>	conf->host = xstrdup(block_state.host.buf);
5441
5442	<	/* Line 1455 of yacc.c  */
5443	<	#line 2979 "ircd_parser.y"
5444	<	{
5445	<	if (conf_parser_ctx.pass == 2)
5446	<	regex_ban = 1;
5442	>	if (block_state.rpass.buf[0])
5443	>	conf->reason = xstrdup(block_state.rpass.buf);
5444	>	else
5445	>	conf->reason = xstrdup(CONF_NOREASON);
5446	>	add_conf_by_address(CONF_KLINE, conf);
5447		}
5448	+	#line 5449 "conf_parser.c"
5449		break;
5450
5451	<	case 465:
5451	>	case 442:
5452	>	#line 2201 "conf_parser.y"
5453	>	{
5454
7020	–	/* Line 1455 of yacc.c  */
7021	–	#line 2988 "ircd_parser.y"
7022	–	{
5455		if (conf_parser_ctx.pass == 2)
5456		{
5457		struct split_nuh_item nuh;
5458
5459		nuh.nuhmask  = yylval.string;
5460		nuh.nickptr  = NULL;
5461	<	nuh.userptr  = userbuf;
5462	<	nuh.hostptr  = hostbuf;
5461	>	nuh.userptr  = block_state.user.buf;
5462	>	nuh.hostptr  = block_state.host.buf;
5463
5464		nuh.nicksize = 0;
5465	<	nuh.usersize = sizeof(userbuf);
5466	<	nuh.hostsize = sizeof(hostbuf);
5465	>	nuh.usersize = sizeof(block_state.user.buf);
5466	>	nuh.hostsize = sizeof(block_state.host.buf);
5467
5468		split_nuh(&nuh);
5469		}
5470		}
5471	+	#line 5472 "conf_parser.c"
5472		break;
5473
5474	<	case 466:
5475	<
5476	<	/* Line 1455 of yacc.c  */
7044	<	#line 3007 "ircd_parser.y"
7045	<	{
5474	>	case 443:
5475	>	#line 2221 "conf_parser.y"
5476	>	{
5477		if (conf_parser_ctx.pass == 2)
5478	<	strlcpy(reasonbuf, yylval.string, sizeof(reasonbuf));
5478	>	strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
5479		}
5480	+	#line 5481 "conf_parser.c"
5481		break;
5482
5483	<	case 467:
5484	<
5485	<	/* Line 1455 of yacc.c  */
7054	<	#line 3016 "ircd_parser.y"
7055	<	{
5483	>	case 444:
5484	>	#line 2231 "conf_parser.y"
5485	>	{
5486		if (conf_parser_ctx.pass == 2)
5487	<	hostbuf[0] = reasonbuf[0] = '\0';
5487	>	reset_block_state();
5488		}
5489	+	#line 5490 "conf_parser.c"
5490		break;
5491
5492	<	case 468:
5492	>	case 445:
5493	>	#line 2235 "conf_parser.y"
5494	>	{
5495	>	if (conf_parser_ctx.pass != 2)
5496	>	break;
5497
5498	<	/* Line 1455 of yacc.c  */
5499	<	#line 3020 "ircd_parser.y"
5500	<	{
5501	<	if (conf_parser_ctx.pass == 2)
5498	>	if (!block_state.addr.buf[0])
5499	>	break;
5500	>
5501	>	if (parse_netmask(block_state.addr.buf, NULL, NULL) != HM_HOST)
5502		{
5503	<	if (hostbuf[0] && parse_netmask(hostbuf, NULL, NULL) != HM_HOST)
5504	<	{
7070	<	yy_aconf = map_to_conf(make_conf_item(DLINE_TYPE));
7071	<	DupString(yy_aconf->host, hostbuf);
5503	>	struct MaskItem *conf = conf_make(CONF_DLINE);
5504	>	conf->host = xstrdup(block_state.addr.buf);
5505
5506	<	if (reasonbuf[0])
5507	<	DupString(yy_aconf->reason, reasonbuf);
5508	<	else
5509	<	DupString(yy_aconf->reason, "No reason");
5510	<	add_conf_by_address(CONF_DLINE, yy_aconf);
7078	<	yy_aconf = NULL;
7079	<	}
5506	>	if (block_state.rpass.buf[0])
5507	>	conf->reason = xstrdup(block_state.rpass.buf);
5508	>	else
5509	>	conf->reason = xstrdup(CONF_NOREASON);
5510	>	add_conf_by_address(CONF_DLINE, conf);
5511		}
5512		}
5513	+	#line 5514 "conf_parser.c"
5514		break;
5515
5516	<	case 474:
5517	<
5518	<	/* Line 1455 of yacc.c  */
7087	<	#line 3042 "ircd_parser.y"
7088	<	{
5516	>	case 451:
5517	>	#line 2259 "conf_parser.y"
5518	>	{
5519		if (conf_parser_ctx.pass == 2)
5520	<	strlcpy(hostbuf, yylval.string, sizeof(hostbuf));
5520	>	strlcpy(block_state.addr.buf, yylval.string, sizeof(block_state.addr.buf));
5521		}
5522	+	#line 5523 "conf_parser.c"
5523		break;
5524
5525	<	case 475:
5526	<
5527	<	/* Line 1455 of yacc.c  */
7097	<	#line 3048 "ircd_parser.y"
7098	<	{
5525	>	case 452:
5526	>	#line 2265 "conf_parser.y"
5527	>	{
5528		if (conf_parser_ctx.pass == 2)
5529	<	strlcpy(reasonbuf, yylval.string, sizeof(reasonbuf));
5529	>	strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
5530		}
5531	+	#line 5532 "conf_parser.c"
5532		break;
5533
5534	<	case 481:
5535	<
5536	<	/* Line 1455 of yacc.c  */
7107	<	#line 3062 "ircd_parser.y"
7108	<	{
5534	>	case 458:
5535	>	#line 2280 "conf_parser.y"
5536	>	{
5537		if (conf_parser_ctx.pass == 2)
5538		{
5539	<	if (yylval.string[0] && parse_netmask(yylval.string, NULL, NULL) != HM_HOST)
5539	>	if (*yylval.string && parse_netmask(yylval.string, NULL, NULL) != HM_HOST)
5540		{
5541	<	yy_aconf = map_to_conf(make_conf_item(EXEMPTDLINE_TYPE));
5542	<	DupString(yy_aconf->host, yylval.string);
5541	>	struct MaskItem *conf = conf_make(CONF_EXEMPT);
5542	>	conf->host = xstrdup(yylval.string);
5543
5544	<	add_conf_by_address(CONF_EXEMPTDLINE, yy_aconf);
7117	<	yy_aconf = NULL;
5544	>	add_conf_by_address(CONF_EXEMPT, conf);
5545		}
5546		}
5547		}
5548	+	#line 5549 "conf_parser.c"
5549		break;
5550
5551	<	case 482:
5552	<
5553	<	/* Line 1455 of yacc.c  */
7126	<	#line 3080 "ircd_parser.y"
7127	<	{
5551	>	case 459:
5552	>	#line 2297 "conf_parser.y"
5553	>	{
5554		if (conf_parser_ctx.pass == 2)
5555	<	{
7130	<	regex_ban = 0;
7131	<	reasonbuf[0] = gecos_name[0] = '\0';
7132	<	}
5555	>	reset_block_state();
5556		}
5557	+	#line 5558 "conf_parser.c"
5558		break;
5559
5560	<	case 483:
5561	<
5562	<	/* Line 1455 of yacc.c  */
5563	<	#line 3087 "ircd_parser.y"
7140	<	{
7141	<	if (conf_parser_ctx.pass == 2)
7142	<	{
7143	<	if (gecos_name[0])
7144	<	{
7145	<	if (regex_ban)
7146	<	{
7147	<	#ifdef HAVE_LIBPCRE
7148	<	void *exp_p = NULL;
7149	<	const char *errptr = NULL;
7150	<
7151	<	if (!(exp_p = ircd_pcre_compile(gecos_name, &errptr)))
7152	<	{
7153	<	ilog(L_ERROR, "Failed to add regular expression based X-Line: %s",
7154	<	errptr);
7155	<	break;
7156	<	}
7157	<
7158	<	yy_conf = make_conf_item(RXLINE_TYPE);
7159	<	yy_conf->regexpname = exp_p;
7160	<	#else
7161	<	ilog(L_ERROR, "Failed to add regular expression based X-Line: no PCRE support");
7162	<	break;
7163	<	#endif
7164	<	}
7165	<	else
7166	<	yy_conf = make_conf_item(XLINE_TYPE);
7167	<
7168	<	yy_match_item = map_to_conf(yy_conf);
7169	<	DupString(yy_conf->name, gecos_name);
7170	<
7171	<	if (reasonbuf[0])
7172	<	DupString(yy_match_item->reason, reasonbuf);
7173	<	else
7174	<	DupString(yy_match_item->reason, "No reason");
7175	<	}
7176	<	}
7177	<	}
5560	>	case 460:
5561	>	#line 2301 "conf_parser.y"
5562	>	{
5563	>	if (conf_parser_ctx.pass != 2)
5564		break;
5565
5566	<	case 484:
7181	<
7182	<	/* Line 1455 of yacc.c  */
7183	<	#line 3127 "ircd_parser.y"
7184	<	{
7185	<	}
5566	>	if (!block_state.name.buf[0])
5567		break;
5568
5569	<	case 488:
5569	>	struct GecosItem *gecos = gecos_make();
5570	>	gecos->mask = xstrdup(block_state.name.buf);
5571
5572	<	/* Line 1455 of yacc.c  */
5573	<	#line 3132 "ircd_parser.y"
5574	<	{
5575	<	if (conf_parser_ctx.pass == 2)
7194	<	regex_ban = 1;
5572	>	if (block_state.rpass.buf[0])
5573	>	gecos->reason = xstrdup(block_state.rpass.buf);
5574	>	else
5575	>	gecos->reason = xstrdup(CONF_NOREASON);
5576		}
5577	+	#line 5578 "conf_parser.c"
5578		break;
5579
5580	<	case 495:
5581	<
5582	<	/* Line 1455 of yacc.c  */
7201	<	#line 3141 "ircd_parser.y"
7202	<	{
5580	>	case 466:
5581	>	#line 2321 "conf_parser.y"
5582	>	{
5583		if (conf_parser_ctx.pass == 2)
5584	<	strlcpy(gecos_name, yylval.string, sizeof(gecos_name));
5584	>	strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
5585		}
5586	+	#line 5587 "conf_parser.c"
5587		break;
5588
5589	<	case 496:
5590	<
5591	<	/* Line 1455 of yacc.c  */
7211	<	#line 3147 "ircd_parser.y"
7212	<	{
5589	>	case 467:
5590	>	#line 2327 "conf_parser.y"
5591	>	{
5592		if (conf_parser_ctx.pass == 2)
5593	<	strlcpy(reasonbuf, yylval.string, sizeof(reasonbuf));
5593	>	strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
5594		}
5595	+	#line 5596 "conf_parser.c"
5596		break;
5597
5598	<	case 557:
5599	<
5600	<	/* Line 1455 of yacc.c  */
5601	<	#line 3192 "ircd_parser.y"
7222	<	{
7223	<	ConfigFileEntry.max_watch = (yyvsp[(3) - (4)].number);
5598	>	case 517:
5599	>	#line 2388 "conf_parser.y"
5600	>	{
5601	>	ConfigGeneral.away_count = (yyvsp[-1].number);
5602		}
5603	+	#line 5604 "conf_parser.c"
5604		break;
5605
5606	<	case 558:
5607	<
5608	<	/* Line 1455 of yacc.c  */
5609	<	#line 3197 "ircd_parser.y"
7231	<	{
7232	<	ConfigFileEntry.gline_min_cidr = (yyvsp[(3) - (4)].number);
5606	>	case 518:
5607	>	#line 2393 "conf_parser.y"
5608	>	{
5609	>	ConfigGeneral.away_time = (yyvsp[-1].number);
5610		}
5611	+	#line 5612 "conf_parser.c"
5612		break;
5613
5614	<	case 559:
5615	<
5616	<	/* Line 1455 of yacc.c  */
5617	<	#line 3202 "ircd_parser.y"
7240	<	{
7241	<	ConfigFileEntry.gline_min_cidr6 = (yyvsp[(3) - (4)].number);
5614	>	case 519:
5615	>	#line 2398 "conf_parser.y"
5616	>	{
5617	>	ConfigGeneral.max_monitor = (yyvsp[-1].number);
5618		}
5619	+	#line 5620 "conf_parser.c"
5620		break;
5621
5622	<	case 560:
5623	<
5624	<	/* Line 1455 of yacc.c  */
5625	<	#line 3207 "ircd_parser.y"
7249	<	{
7250	<	ConfigFileEntry.burst_away = yylval.number;
5622	>	case 520:
5623	>	#line 2403 "conf_parser.y"
5624	>	{
5625	>	ConfigGeneral.whowas_history_length = (yyvsp[-1].number);
5626		}
5627	+	#line 5628 "conf_parser.c"
5628		break;
5629
5630	<	case 561:
5631	<
5632	<	/* Line 1455 of yacc.c  */
5633	<	#line 3212 "ircd_parser.y"
7258	<	{
7259	<	ConfigFileEntry.use_whois_actually = yylval.number;
5630	>	case 521:
5631	>	#line 2408 "conf_parser.y"
5632	>	{
5633	>	ConfigGeneral.cycle_on_host_change = yylval.number;
5634		}
5635	+	#line 5636 "conf_parser.c"
5636		break;
5637
5638	<	case 562:
5639	<
5640	<	/* Line 1455 of yacc.c  */
5641	<	#line 3217 "ircd_parser.y"
7267	<	{
7268	<	GlobalSetOptions.rejecttime = yylval.number;
5638	>	case 522:
5639	>	#line 2413 "conf_parser.y"
5640	>	{
5641	>	ConfigGeneral.dline_min_cidr = (yyvsp[-1].number);
5642		}
5643	+	#line 5644 "conf_parser.c"
5644		break;
5645
5646	<	case 563:
5647	<
5648	<	/* Line 1455 of yacc.c  */
5649	<	#line 3222 "ircd_parser.y"
7276	<	{
7277	<	ConfigFileEntry.tkline_expire_notices = yylval.number;
5646	>	case 523:
5647	>	#line 2418 "conf_parser.y"
5648	>	{
5649	>	ConfigGeneral.dline_min_cidr6 = (yyvsp[-1].number);
5650		}
5651	+	#line 5652 "conf_parser.c"
5652		break;
5653
5654	<	case 564:
5655	<
5656	<	/* Line 1455 of yacc.c  */
5657	<	#line 3227 "ircd_parser.y"
7285	<	{
7286	<	ConfigFileEntry.kill_chase_time_limit = (yyvsp[(3) - (4)].number);
5654	>	case 524:
5655	>	#line 2423 "conf_parser.y"
5656	>	{
5657	>	ConfigGeneral.kline_min_cidr = (yyvsp[-1].number);
5658		}
5659	+	#line 5660 "conf_parser.c"
5660		break;
5661
5662	<	case 565:
5663	<
5664	<	/* Line 1455 of yacc.c  */
5665	<	#line 3232 "ircd_parser.y"
7294	<	{
7295	<	ConfigFileEntry.hide_spoof_ips = yylval.number;
5662	>	case 525:
5663	>	#line 2428 "conf_parser.y"
5664	>	{
5665	>	ConfigGeneral.kline_min_cidr6 = (yyvsp[-1].number);
5666		}
5667	+	#line 5668 "conf_parser.c"
5668		break;
5669
5670	<	case 566:
5671	<
5672	<	/* Line 1455 of yacc.c  */
5673	<	#line 3237 "ircd_parser.y"
7303	<	{
7304	<	ConfigFileEntry.ignore_bogus_ts = yylval.number;
5670	>	case 526:
5671	>	#line 2433 "conf_parser.y"
5672	>	{
5673	>	ConfigGeneral.kill_chase_time_limit = (yyvsp[-1].number);
5674		}
5675	+	#line 5676 "conf_parser.c"
5676		break;
5677
5678	<	case 567:
5679	<
5680	<	/* Line 1455 of yacc.c  */
5681	<	#line 3242 "ircd_parser.y"
7312	<	{
7313	<	ConfigFileEntry.disable_remote = yylval.number;
5678	>	case 527:
5679	>	#line 2438 "conf_parser.y"
5680	>	{
5681	>	ConfigGeneral.failed_oper_notice = yylval.number;
5682		}
5683	+	#line 5684 "conf_parser.c"
5684		break;
5685
5686	<	case 568:
5687	<
5688	<	/* Line 1455 of yacc.c  */
5689	<	#line 3247 "ircd_parser.y"
7321	<	{
7322	<	ConfigFileEntry.failed_oper_notice = yylval.number;
5686	>	case 528:
5687	>	#line 2443 "conf_parser.y"
5688	>	{
5689	>	ConfigGeneral.anti_nick_flood = yylval.number;
5690		}
5691	+	#line 5692 "conf_parser.c"
5692		break;
5693
5694	<	case 569:
5695	<
5696	<	/* Line 1455 of yacc.c  */
5697	<	#line 3252 "ircd_parser.y"
7330	<	{
7331	<	ConfigFileEntry.anti_nick_flood = yylval.number;
5694	>	case 529:
5695	>	#line 2448 "conf_parser.y"
5696	>	{
5697	>	ConfigGeneral.max_nick_time = (yyvsp[-1].number);
5698		}
5699	+	#line 5700 "conf_parser.c"
5700		break;
5701
5702	<	case 570:
5703	<
5704	<	/* Line 1455 of yacc.c  */
5705	<	#line 3257 "ircd_parser.y"
7339	<	{
7340	<	ConfigFileEntry.max_nick_time = (yyvsp[(3) - (4)].number);
5702	>	case 530:
5703	>	#line 2453 "conf_parser.y"
5704	>	{
5705	>	ConfigGeneral.max_nick_changes = (yyvsp[-1].number);
5706		}
5707	+	#line 5708 "conf_parser.c"
5708		break;
5709
5710	<	case 571:
5711	<
5712	<	/* Line 1455 of yacc.c  */
5713	<	#line 3262 "ircd_parser.y"
7348	<	{
7349	<	ConfigFileEntry.max_nick_changes = (yyvsp[(3) - (4)].number);
5710	>	case 531:
5711	>	#line 2458 "conf_parser.y"
5712	>	{
5713	>	ConfigGeneral.max_accept = (yyvsp[-1].number);
5714		}
5715	+	#line 5716 "conf_parser.c"
5716		break;
5717
5718	<	case 572:
5719	<
5720	<	/* Line 1455 of yacc.c  */
5721	<	#line 3267 "ircd_parser.y"
7357	<	{
7358	<	ConfigFileEntry.max_accept = (yyvsp[(3) - (4)].number);
5718	>	case 532:
5719	>	#line 2463 "conf_parser.y"
5720	>	{
5721	>	ConfigGeneral.anti_spam_exit_message_time = (yyvsp[-1].number);
5722		}
5723	+	#line 5724 "conf_parser.c"
5724		break;
5725
5726	<	case 573:
5727	<
5728	<	/* Line 1455 of yacc.c  */
5729	<	#line 3272 "ircd_parser.y"
7366	<	{
7367	<	ConfigFileEntry.anti_spam_exit_message_time = (yyvsp[(3) - (4)].number);
5726	>	case 533:
5727	>	#line 2468 "conf_parser.y"
5728	>	{
5729	>	ConfigGeneral.ts_warn_delta = (yyvsp[-1].number);
5730		}
5731	+	#line 5732 "conf_parser.c"
5732		break;
5733
5734	<	case 574:
5735	<
5736	<	/* Line 1455 of yacc.c  */
5737	<	#line 3277 "ircd_parser.y"
7375	<	{
7376	<	ConfigFileEntry.ts_warn_delta = (yyvsp[(3) - (4)].number);
5734	>	case 534:
5735	>	#line 2473 "conf_parser.y"
5736	>	{
5737	>	ConfigGeneral.ts_max_delta = (yyvsp[-1].number);
5738		}
5739	+	#line 5740 "conf_parser.c"
5740		break;
5741
5742	<	case 575:
5743	<
5744	<	/* Line 1455 of yacc.c  */
5745	<	#line 3282 "ircd_parser.y"
7384	<	{
7385	<	if (conf_parser_ctx.pass == 2)
7386	<	ConfigFileEntry.ts_max_delta = (yyvsp[(3) - (4)].number);
5742	>	case 535:
5743	>	#line 2478 "conf_parser.y"
5744	>	{
5745	>	ConfigGeneral.invisible_on_connect = yylval.number;
5746		}
5747	+	#line 5748 "conf_parser.c"
5748		break;
5749
5750	<	case 576:
5751	<
5752	<	/* Line 1455 of yacc.c  */
5753	<	#line 3288 "ircd_parser.y"
7394	<	{
7395	<	if (((yyvsp[(3) - (4)].number) > 0) && conf_parser_ctx.pass == 1)
7396	<	{
7397	<	ilog(L_CRIT, "You haven't read your config file properly.");
7398	<	ilog(L_CRIT, "There is a line in the example conf that will kill your server if not removed.");
7399	<	ilog(L_CRIT, "Consider actually reading/editing the conf file, and removing this line.");
7400	<	exit(0);
7401	<	}
5750	>	case 536:
5751	>	#line 2483 "conf_parser.y"
5752	>	{
5753	>	ConfigGeneral.warn_no_connect_block = yylval.number;
5754		}
5755	+	#line 5756 "conf_parser.c"
5756		break;
5757
5758	<	case 577:
5759	<
5760	<	/* Line 1455 of yacc.c  */
5761	<	#line 3299 "ircd_parser.y"
7409	<	{
7410	<	ConfigFileEntry.kline_with_reason = yylval.number;
5758	>	case 537:
5759	>	#line 2488 "conf_parser.y"
5760	>	{
5761	>	ConfigGeneral.stats_e_disabled = yylval.number;
5762		}
5763	+	#line 5764 "conf_parser.c"
5764		break;
5765
5766	<	case 578:
5767	<
5768	<	/* Line 1455 of yacc.c  */
5769	<	#line 3304 "ircd_parser.y"
7418	<	{
7419	<	if (conf_parser_ctx.pass == 2)
7420	<	{
7421	<	MyFree(ConfigFileEntry.kline_reason);
7422	<	DupString(ConfigFileEntry.kline_reason, yylval.string);
7423	<	}
5766	>	case 538:
5767	>	#line 2493 "conf_parser.y"
5768	>	{
5769	>	ConfigGeneral.stats_m_oper_only = yylval.number;
5770		}
5771	+	#line 5772 "conf_parser.c"
5772		break;
5773
5774	<	case 579:
5775	<
5776	<	/* Line 1455 of yacc.c  */
5777	<	#line 3313 "ircd_parser.y"
7431	<	{
7432	<	ConfigFileEntry.invisible_on_connect = yylval.number;
5774	>	case 539:
5775	>	#line 2498 "conf_parser.y"
5776	>	{
5777	>	ConfigGeneral.stats_o_oper_only = yylval.number;
5778		}
5779	+	#line 5780 "conf_parser.c"
5780		break;
5781
5782	<	case 580:
5783	<
5784	<	/* Line 1455 of yacc.c  */
5785	<	#line 3318 "ircd_parser.y"
7440	<	{
7441	<	ConfigFileEntry.warn_no_nline = yylval.number;
5782	>	case 540:
5783	>	#line 2503 "conf_parser.y"
5784	>	{
5785	>	ConfigGeneral.stats_P_oper_only = yylval.number;
5786		}
5787	+	#line 5788 "conf_parser.c"
5788		break;
5789
5790	<	case 581:
5791	<
5792	<	/* Line 1455 of yacc.c  */
5793	<	#line 3323 "ircd_parser.y"
7449	<	{
7450	<	ConfigFileEntry.stats_e_disabled = yylval.number;
5790	>	case 541:
5791	>	#line 2508 "conf_parser.y"
5792	>	{
5793	>	ConfigGeneral.stats_u_oper_only = yylval.number;
5794		}
5795	+	#line 5796 "conf_parser.c"
5796		break;
5797
5798	<	case 582:
5799	<
5800	<	/* Line 1455 of yacc.c  */
5801	<	#line 3328 "ircd_parser.y"
7458	<	{
7459	<	ConfigFileEntry.stats_o_oper_only = yylval.number;
5798	>	case 542:
5799	>	#line 2513 "conf_parser.y"
5800	>	{
5801	>	ConfigGeneral.stats_k_oper_only = yylval.number;
5802		}
5803	+	#line 5804 "conf_parser.c"
5804		break;
5805
5806	<	case 583:
5807	<
5808	<	/* Line 1455 of yacc.c  */
5809	<	#line 3333 "ircd_parser.y"
7467	<	{
7468	<	ConfigFileEntry.stats_P_oper_only = yylval.number;
5806	>	case 543:
5807	>	#line 2518 "conf_parser.y"
5808	>	{
5809	>	ConfigGeneral.stats_i_oper_only = yylval.number;
5810		}
5811	+	#line 5812 "conf_parser.c"
5812		break;
5813
5814	<	case 584:
5815	<
5816	<	/* Line 1455 of yacc.c  */
5817	<	#line 3338 "ircd_parser.y"
7476	<	{
7477	<	ConfigFileEntry.stats_k_oper_only = 2 * yylval.number;
5814	>	case 544:
5815	>	#line 2523 "conf_parser.y"
5816	>	{
5817	>	ConfigGeneral.pace_wait = (yyvsp[-1].number);
5818		}
5819	+	#line 5820 "conf_parser.c"
5820		break;
5821
5822	<	case 585:
5823	<
5824	<	/* Line 1455 of yacc.c  */
5825	<	#line 3341 "ircd_parser.y"
7485	<	{
7486	<	ConfigFileEntry.stats_k_oper_only = 1;
5822	>	case 545:
5823	>	#line 2528 "conf_parser.y"
5824	>	{
5825	>	ConfigGeneral.caller_id_wait = (yyvsp[-1].number);
5826		}
5827	+	#line 5828 "conf_parser.c"
5828		break;
5829
5830	<	case 586:
5831	<
5832	<	/* Line 1455 of yacc.c  */
5833	<	#line 3346 "ircd_parser.y"
7494	<	{
7495	<	ConfigFileEntry.stats_i_oper_only = 2 * yylval.number;
5830	>	case 546:
5831	>	#line 2533 "conf_parser.y"
5832	>	{
5833	>	ConfigGeneral.opers_bypass_callerid = yylval.number;
5834		}
5835	+	#line 5836 "conf_parser.c"
5836		break;
5837
5838	<	case 587:
5839	<
5840	<	/* Line 1455 of yacc.c  */
5841	<	#line 3349 "ircd_parser.y"
7503	<	{
7504	<	ConfigFileEntry.stats_i_oper_only = 1;
5838	>	case 547:
5839	>	#line 2538 "conf_parser.y"
5840	>	{
5841	>	ConfigGeneral.pace_wait_simple = (yyvsp[-1].number);
5842		}
5843	+	#line 5844 "conf_parser.c"
5844		break;
5845
5846	<	case 588:
5847	<
5848	<	/* Line 1455 of yacc.c  */
5849	<	#line 3354 "ircd_parser.y"
7512	<	{
7513	<	ConfigFileEntry.pace_wait = (yyvsp[(3) - (4)].number);
5846	>	case 548:
5847	>	#line 2543 "conf_parser.y"
5848	>	{
5849	>	ConfigGeneral.short_motd = yylval.number;
5850		}
5851	+	#line 5852 "conf_parser.c"
5852		break;
5853
5854	<	case 589:
5855	<
5856	<	/* Line 1455 of yacc.c  */
5857	<	#line 3359 "ircd_parser.y"
7521	<	{
7522	<	ConfigFileEntry.caller_id_wait = (yyvsp[(3) - (4)].number);
5854	>	case 549:
5855	>	#line 2548 "conf_parser.y"
5856	>	{
5857	>	ConfigGeneral.no_oper_flood = yylval.number;
5858		}
5859	+	#line 5860 "conf_parser.c"
5860		break;
5861
5862	<	case 590:
5863	<
5864	<	/* Line 1455 of yacc.c  */
5865	<	#line 3364 "ircd_parser.y"
7530	<	{
7531	<	ConfigFileEntry.opers_bypass_callerid = yylval.number;
5862	>	case 550:
5863	>	#line 2553 "conf_parser.y"
5864	>	{
5865	>	ConfigGeneral.dots_in_ident = (yyvsp[-1].number);
5866		}
5867	+	#line 5868 "conf_parser.c"
5868		break;
5869
5870	<	case 591:
5871	<
5872	<	/* Line 1455 of yacc.c  */
5873	<	#line 3369 "ircd_parser.y"
7539	<	{
7540	<	ConfigFileEntry.pace_wait_simple = (yyvsp[(3) - (4)].number);
5870	>	case 551:
5871	>	#line 2558 "conf_parser.y"
5872	>	{
5873	>	ConfigGeneral.max_targets = (yyvsp[-1].number);
5874		}
5875	+	#line 5876 "conf_parser.c"
5876		break;
5877
5878	<	case 592:
5879	<
5880	<	/* Line 1455 of yacc.c  */
5881	<	#line 3374 "ircd_parser.y"
7548	<	{
7549	<	ConfigFileEntry.short_motd = yylval.number;
5878	>	case 552:
5879	>	#line 2563 "conf_parser.y"
5880	>	{
5881	>	ConfigGeneral.ping_cookie = yylval.number;
5882		}
5883	+	#line 5884 "conf_parser.c"
5884		break;
5885
5886	<	case 593:
5887	<
5888	<	/* Line 1455 of yacc.c  */
5889	<	#line 3379 "ircd_parser.y"
7557	<	{
7558	<	ConfigFileEntry.no_oper_flood = yylval.number;
5886	>	case 553:
5887	>	#line 2568 "conf_parser.y"
5888	>	{
5889	>	ConfigGeneral.disable_auth = yylval.number;
5890		}
5891	+	#line 5892 "conf_parser.c"
5892		break;
5893
5894	<	case 594:
5895	<
5896	<	/* Line 1455 of yacc.c  */
5897	<	#line 3384 "ircd_parser.y"
7566	<	{
7567	<	ConfigFileEntry.true_no_oper_flood = yylval.number;
5894	>	case 554:
5895	>	#line 2573 "conf_parser.y"
5896	>	{
5897	>	ConfigGeneral.throttle_count = (yyvsp[-1].number);
5898		}
5899	+	#line 5900 "conf_parser.c"
5900		break;
5901
5902	<	case 595:
5903	<
5904	<	/* Line 1455 of yacc.c  */
5905	<	#line 3389 "ircd_parser.y"
7575	<	{
7576	<	ConfigFileEntry.oper_pass_resv = yylval.number;
5902	>	case 555:
5903	>	#line 2578 "conf_parser.y"
5904	>	{
5905	>	ConfigGeneral.throttle_time = (yyvsp[-1].number);
5906		}
5907	+	#line 5908 "conf_parser.c"
5908		break;
5909
5910	<	case 596:
5911	<
5912	<	/* Line 1455 of yacc.c  */
5913	<	#line 3394 "ircd_parser.y"
7584	<	{
7585	<	if (conf_parser_ctx.pass == 2)
7586	<	{
7587	<	if (strlen(yylval.string) > LOCALE_LENGTH-2)
7588	<	yylval.string[LOCALE_LENGTH-1] = '\0';
7589	<
7590	<	set_locale(yylval.string);
7591	<	}
5910	>	case 556:
5911	>	#line 2583 "conf_parser.y"
5912	>	{
5913	>	ConfigGeneral.oper_umodes = 0;
5914		}
5915	+	#line 5916 "conf_parser.c"
5916		break;
5917
5918	<	case 597:
5919	<
5920	<	/* Line 1455 of yacc.c  */
5921	<	#line 3405 "ircd_parser.y"
7599	<	{
7600	<	ConfigFileEntry.idletime = (yyvsp[(3) - (4)].number);
5918	>	case 560:
5919	>	#line 2589 "conf_parser.y"
5920	>	{
5921	>	ConfigGeneral.oper_umodes |= UMODE_BOT;
5922		}
5923	+	#line 5924 "conf_parser.c"
5924		break;
5925
5926	<	case 598:
5927	<
5928	<	/* Line 1455 of yacc.c  */
5929	<	#line 3410 "ircd_parser.y"
7608	<	{
7609	<	ConfigFileEntry.dots_in_ident = (yyvsp[(3) - (4)].number);
5926	>	case 561:
5927	>	#line 2592 "conf_parser.y"
5928	>	{
5929	>	ConfigGeneral.oper_umodes |= UMODE_CCONN;
5930		}
5931	+	#line 5932 "conf_parser.c"
5932		break;
5933
5934	<	case 599:
5935	<
5936	<	/* Line 1455 of yacc.c  */
5937	<	#line 3415 "ircd_parser.y"
7617	<	{
7618	<	ConfigFileEntry.max_targets = (yyvsp[(3) - (4)].number);
5934	>	case 562:
5935	>	#line 2595 "conf_parser.y"
5936	>	{
5937	>	ConfigGeneral.oper_umodes |= UMODE_DEAF;
5938		}
5939	+	#line 5940 "conf_parser.c"
5940		break;
5941
5942	<	case 600:
5943	<
5944	<	/* Line 1455 of yacc.c  */
5945	<	#line 3420 "ircd_parser.y"
7626	<	{
7627	<	if (conf_parser_ctx.pass == 2)
7628	<	{
7629	<	MyFree(ConfigFileEntry.servlink_path);
7630	<	DupString(ConfigFileEntry.servlink_path, yylval.string);
7631	<	}
5942	>	case 563:
5943	>	#line 2598 "conf_parser.y"
5944	>	{
5945	>	ConfigGeneral.oper_umodes |= UMODE_DEBUG;
5946		}
5947	+	#line 5948 "conf_parser.c"
5948		break;
5949
5950	<	case 601:
5951	<
5952	<	/* Line 1455 of yacc.c  */
5953	<	#line 3429 "ircd_parser.y"
7639	<	{
7640	<	#ifdef HAVE_LIBCRYPTO
7641	<	if (conf_parser_ctx.pass == 2)
7642	<	{
7643	<	struct EncCapability *ecap;
7644	<	const char *cipher_name;
7645	<	int found = 0;
7646	<
7647	<	ConfigFileEntry.default_cipher_preference = NULL;
7648	<	cipher_name = yylval.string;
7649	<
7650	<	for (ecap = CipherTable; ecap->name; ecap++)
7651	<	{
7652	<	if ((irccmp(ecap->name, cipher_name) == 0) &&
7653	<	(ecap->cap & CAP_ENC_MASK))
7654	<	{
7655	<	ConfigFileEntry.default_cipher_preference = ecap;
7656	<	found = 1;
7657	<	break;
7658	<	}
7659	<	}
7660	<
7661	<	if (!found)
7662	<	yyerror("Invalid cipher");
7663	<	}
7664	<	#else
7665	<	if (conf_parser_ctx.pass == 2)
7666	<	yyerror("Ignoring default_cipher_preference -- no OpenSSL support");
7667	<	#endif
5950	>	case 564:
5951	>	#line 2601 "conf_parser.y"
5952	>	{
5953	>	ConfigGeneral.oper_umodes |= UMODE_FLOOD;
5954		}
5955	+	#line 5956 "conf_parser.c"
5956		break;
5957
5958	<	case 602:
5959	<
5960	<	/* Line 1455 of yacc.c  */
5961	<	#line 3461 "ircd_parser.y"
7675	<	{
7676	<	if (conf_parser_ctx.pass == 2)
7677	<	{
7678	<	ConfigFileEntry.compression_level = (yyvsp[(3) - (4)].number);
7679	<	#ifndef HAVE_LIBZ
7680	<	yyerror("Ignoring compression_level -- no zlib support");
7681	<	#else
7682	<	if ((ConfigFileEntry.compression_level < 1) ||
7683	<	(ConfigFileEntry.compression_level > 9))
7684	<	{
7685	<	yyerror("Ignoring invalid compression_level, using default");
7686	<	ConfigFileEntry.compression_level = 0;
7687	<	}
7688	<	#endif
7689	<	}
5958	>	case 565:
5959	>	#line 2604 "conf_parser.y"
5960	>	{
5961	>	ConfigGeneral.oper_umodes |= UMODE_HIDDEN;
5962		}
5963	+	#line 5964 "conf_parser.c"
5964		break;
5965
5966	<	case 603:
5967	<
5968	<	/* Line 1455 of yacc.c  */
5969	<	#line 3479 "ircd_parser.y"
7697	<	{
7698	<	ConfigFileEntry.use_egd = yylval.number;
5966	>	case 566:
5967	>	#line 2607 "conf_parser.y"
5968	>	{
5969	>	ConfigGeneral.oper_umodes |= UMODE_HIDECHANS;
5970		}
5971	+	#line 5972 "conf_parser.c"
5972		break;
5973
5974	<	case 604:
5975	<
5976	<	/* Line 1455 of yacc.c  */
5977	<	#line 3484 "ircd_parser.y"
7706	<	{
7707	<	if (conf_parser_ctx.pass == 2)
7708	<	{
7709	<	MyFree(ConfigFileEntry.egdpool_path);
7710	<	DupString(ConfigFileEntry.egdpool_path, yylval.string);
7711	<	}
5974	>	case 567:
5975	>	#line 2610 "conf_parser.y"
5976	>	{
5977	>	ConfigGeneral.oper_umodes |= UMODE_HIDEIDLE;
5978		}
5979	+	#line 5980 "conf_parser.c"
5980		break;
5981
5982	<	case 605:
5983	<
5984	<	/* Line 1455 of yacc.c  */
5985	<	#line 3493 "ircd_parser.y"
7719	<	{
7720	<	ConfigFileEntry.ping_cookie = yylval.number;
5982	>	case 568:
5983	>	#line 2613 "conf_parser.y"
5984	>	{
5985	>	ConfigGeneral.oper_umodes |= UMODE_SKILL;
5986		}
5987	+	#line 5988 "conf_parser.c"
5988		break;
5989
5990	<	case 606:
5991	<
5992	<	/* Line 1455 of yacc.c  */
5993	<	#line 3498 "ircd_parser.y"
7728	<	{
7729	<	ConfigFileEntry.disable_auth = yylval.number;
5990	>	case 569:
5991	>	#line 2616 "conf_parser.y"
5992	>	{
5993	>	ConfigGeneral.oper_umodes |= UMODE_NCHANGE;
5994		}
5995	+	#line 5996 "conf_parser.c"
5996		break;
5997
5998	<	case 607:
5999	<
6000	<	/* Line 1455 of yacc.c  */
6001	<	#line 3503 "ircd_parser.y"
7737	<	{
7738	<	ConfigFileEntry.throttle_time = yylval.number;
5998	>	case 570:
5999	>	#line 2619 "conf_parser.y"
6000	>	{
6001	>	ConfigGeneral.oper_umodes |= UMODE_REJ;
6002		}
6003	+	#line 6004 "conf_parser.c"
6004		break;
6005
6006	<	case 608:
6007	<
6008	<	/* Line 1455 of yacc.c  */
6009	<	#line 3508 "ircd_parser.y"
7746	<	{
7747	<	ConfigFileEntry.oper_umodes = 0;
6006	>	case 571:
6007	>	#line 2622 "conf_parser.y"
6008	>	{
6009	>	ConfigGeneral.oper_umodes |= UMODE_SPY;
6010		}
6011	+	#line 6012 "conf_parser.c"
6012		break;
6013
6014	<	case 612:
6015	<
6016	<	/* Line 1455 of yacc.c  */
6017	<	#line 3514 "ircd_parser.y"
7755	<	{
7756	<	ConfigFileEntry.oper_umodes |= UMODE_BOTS;
6014	>	case 572:
6015	>	#line 2625 "conf_parser.y"
6016	>	{
6017	>	ConfigGeneral.oper_umodes |= UMODE_EXTERNAL;
6018		}
6019	+	#line 6020 "conf_parser.c"
6020		break;
6021
6022	<	case 613:
6023	<
6024	<	/* Line 1455 of yacc.c  */
6025	<	#line 3517 "ircd_parser.y"
7764	<	{
7765	<	ConfigFileEntry.oper_umodes |= UMODE_CCONN;
6022	>	case 573:
6023	>	#line 2628 "conf_parser.y"
6024	>	{
6025	>	ConfigGeneral.oper_umodes |= UMODE_SERVNOTICE;
6026		}
6027	+	#line 6028 "conf_parser.c"
6028		break;
6029
6030	<	case 614:
6031	<
6032	<	/* Line 1455 of yacc.c  */
6033	<	#line 3520 "ircd_parser.y"
7773	<	{
7774	<	ConfigFileEntry.oper_umodes |= UMODE_CCONN_FULL;
6030	>	case 574:
6031	>	#line 2631 "conf_parser.y"
6032	>	{
6033	>	ConfigGeneral.oper_umodes |= UMODE_INVISIBLE;
6034		}
6035	+	#line 6036 "conf_parser.c"
6036		break;
6037
6038	<	case 615:
6039	<
6040	<	/* Line 1455 of yacc.c  */
6041	<	#line 3523 "ircd_parser.y"
7782	<	{
7783	<	ConfigFileEntry.oper_umodes |= UMODE_DEAF;
6038	>	case 575:
6039	>	#line 2634 "conf_parser.y"
6040	>	{
6041	>	ConfigGeneral.oper_umodes |= UMODE_WALLOP;
6042		}
6043	+	#line 6044 "conf_parser.c"
6044		break;
6045
6046	<	case 616:
6047	<
6048	<	/* Line 1455 of yacc.c  */
6049	<	#line 3526 "ircd_parser.y"
7791	<	{
7792	<	ConfigFileEntry.oper_umodes |= UMODE_DEBUG;
6046	>	case 576:
6047	>	#line 2637 "conf_parser.y"
6048	>	{
6049	>	ConfigGeneral.oper_umodes |= UMODE_SOFTCALLERID;
6050		}
6051	+	#line 6052 "conf_parser.c"
6052		break;
6053
6054	<	case 617:
6055	<
6056	<	/* Line 1455 of yacc.c  */
6057	<	#line 3529 "ircd_parser.y"
7800	<	{
7801	<	ConfigFileEntry.oper_umodes |= UMODE_FULL;
6054	>	case 577:
6055	>	#line 2640 "conf_parser.y"
6056	>	{
6057	>	ConfigGeneral.oper_umodes |= UMODE_CALLERID;
6058		}
6059	+	#line 6060 "conf_parser.c"
6060		break;
6061
6062	<	case 618:
6063	<
6064	<	/* Line 1455 of yacc.c  */
6065	<	#line 3532 "ircd_parser.y"
7809	<	{
7810	<	ConfigFileEntry.oper_umodes |= UMODE_SKILL;
6062	>	case 578:
6063	>	#line 2643 "conf_parser.y"
6064	>	{
6065	>	ConfigGeneral.oper_umodes |= UMODE_LOCOPS;
6066		}
6067	+	#line 6068 "conf_parser.c"
6068		break;
6069
6070	<	case 619:
6071	<
6072	<	/* Line 1455 of yacc.c  */
6073	<	#line 3535 "ircd_parser.y"
7818	<	{
7819	<	ConfigFileEntry.oper_umodes |= UMODE_NCHANGE;
6070	>	case 579:
6071	>	#line 2646 "conf_parser.y"
6072	>	{
6073	>	ConfigGeneral.oper_umodes |= UMODE_REGONLY;
6074		}
6075	+	#line 6076 "conf_parser.c"
6076		break;
6077
6078	<	case 620:
6079	<
6080	<	/* Line 1455 of yacc.c  */
6081	<	#line 3538 "ircd_parser.y"
7827	<	{
7828	<	ConfigFileEntry.oper_umodes |= UMODE_REJ;
6078	>	case 580:
6079	>	#line 2649 "conf_parser.y"
6080	>	{
6081	>	ConfigGeneral.oper_umodes |= UMODE_FARCONNECT;
6082		}
6083	+	#line 6084 "conf_parser.c"
6084		break;
6085
6086	<	case 621:
6087	<
6088	<	/* Line 1455 of yacc.c  */
6089	<	#line 3541 "ircd_parser.y"
7836	<	{
7837	<	ConfigFileEntry.oper_umodes |= UMODE_UNAUTH;
6086	>	case 581:
6087	>	#line 2652 "conf_parser.y"
6088	>	{
6089	>	ConfigGeneral.oper_umodes |= UMODE_EXPIRATION;
6090		}
6091	+	#line 6092 "conf_parser.c"
6092		break;
6093
6094	<	case 622:
6095	<
6096	<	/* Line 1455 of yacc.c  */
6097	<	#line 3544 "ircd_parser.y"
7845	<	{
7846	<	ConfigFileEntry.oper_umodes |= UMODE_SPY;
6094	>	case 582:
6095	>	#line 2657 "conf_parser.y"
6096	>	{
6097	>	ConfigGeneral.oper_only_umodes = 0;
6098		}
6099	+	#line 6100 "conf_parser.c"
6100		break;
6101
6102	<	case 623:
6103	<
6104	<	/* Line 1455 of yacc.c  */
6105	<	#line 3547 "ircd_parser.y"
7854	<	{
7855	<	ConfigFileEntry.oper_umodes |= UMODE_EXTERNAL;
6102	>	case 586:
6103	>	#line 2663 "conf_parser.y"
6104	>	{
6105	>	ConfigGeneral.oper_only_umodes |= UMODE_BOT;
6106		}
6107	+	#line 6108 "conf_parser.c"
6108		break;
6109
6110	<	case 624:
6111	<
6112	<	/* Line 1455 of yacc.c  */
6113	<	#line 3550 "ircd_parser.y"
7863	<	{
7864	<	ConfigFileEntry.oper_umodes |= UMODE_OPERWALL;
6110	>	case 587:
6111	>	#line 2666 "conf_parser.y"
6112	>	{
6113	>	ConfigGeneral.oper_only_umodes |= UMODE_CCONN;
6114		}
6115	+	#line 6116 "conf_parser.c"
6116		break;
6117
6118	<	case 625:
6119	<
6120	<	/* Line 1455 of yacc.c  */
6121	<	#line 3553 "ircd_parser.y"
7872	<	{
7873	<	ConfigFileEntry.oper_umodes |= UMODE_SERVNOTICE;
6118	>	case 588:
6119	>	#line 2669 "conf_parser.y"
6120	>	{
6121	>	ConfigGeneral.oper_only_umodes |= UMODE_DEAF;
6122		}
6123	+	#line 6124 "conf_parser.c"
6124		break;
6125
6126	<	case 626:
6127	<
6128	<	/* Line 1455 of yacc.c  */
6129	<	#line 3556 "ircd_parser.y"
7881	<	{
7882	<	ConfigFileEntry.oper_umodes |= UMODE_INVISIBLE;
6126	>	case 589:
6127	>	#line 2672 "conf_parser.y"
6128	>	{
6129	>	ConfigGeneral.oper_only_umodes |= UMODE_DEBUG;
6130		}
6131	+	#line 6132 "conf_parser.c"
6132		break;
6133
6134	<	case 627:
6135	<
6136	<	/* Line 1455 of yacc.c  */
6137	<	#line 3559 "ircd_parser.y"
7890	<	{
7891	<	ConfigFileEntry.oper_umodes |= UMODE_WALLOP;
6134	>	case 590:
6135	>	#line 2675 "conf_parser.y"
6136	>	{
6137	>	ConfigGeneral.oper_only_umodes |= UMODE_FLOOD;
6138		}
6139	+	#line 6140 "conf_parser.c"
6140		break;
6141
6142	<	case 628:
6143	<
6144	<	/* Line 1455 of yacc.c  */
6145	<	#line 3562 "ircd_parser.y"
7899	<	{
7900	<	ConfigFileEntry.oper_umodes |= UMODE_SOFTCALLERID;
6142	>	case 591:
6143	>	#line 2678 "conf_parser.y"
6144	>	{
6145	>	ConfigGeneral.oper_only_umodes |= UMODE_SKILL;
6146		}
6147	+	#line 6148 "conf_parser.c"
6148		break;
6149
6150	<	case 629:
6151	<
6152	<	/* Line 1455 of yacc.c  */
6153	<	#line 3565 "ircd_parser.y"
7908	<	{
7909	<	ConfigFileEntry.oper_umodes |= UMODE_CALLERID;
6150	>	case 592:
6151	>	#line 2681 "conf_parser.y"
6152	>	{
6153	>	ConfigGeneral.oper_only_umodes |= UMODE_HIDDEN;
6154		}
6155	+	#line 6156 "conf_parser.c"
6156		break;
6157
6158	<	case 630:
6159	<
6160	<	/* Line 1455 of yacc.c  */
6161	<	#line 3568 "ircd_parser.y"
7917	<	{
7918	<	ConfigFileEntry.oper_umodes |= UMODE_LOCOPS;
6158	>	case 593:
6159	>	#line 2684 "conf_parser.y"
6160	>	{
6161	>	ConfigGeneral.oper_only_umodes |= UMODE_NCHANGE;
6162		}
6163	+	#line 6164 "conf_parser.c"
6164		break;
6165
6166	<	case 631:
6167	<
6168	<	/* Line 1455 of yacc.c  */
6169	<	#line 3573 "ircd_parser.y"
7926	<	{
7927	<	ConfigFileEntry.oper_only_umodes = 0;
6166	>	case 594:
6167	>	#line 2687 "conf_parser.y"
6168	>	{
6169	>	ConfigGeneral.oper_only_umodes |= UMODE_REJ;
6170		}
6171	+	#line 6172 "conf_parser.c"
6172		break;
6173
6174	<	case 635:
6175	<
6176	<	/* Line 1455 of yacc.c  */
6177	<	#line 3579 "ircd_parser.y"
7935	<	{
7936	<	ConfigFileEntry.oper_only_umodes |= UMODE_BOTS;
6174	>	case 595:
6175	>	#line 2690 "conf_parser.y"
6176	>	{
6177	>	ConfigGeneral.oper_only_umodes |= UMODE_SPY;
6178		}
6179	+	#line 6180 "conf_parser.c"
6180		break;
6181
6182	<	case 636:
6183	<
6184	<	/* Line 1455 of yacc.c  */
6185	<	#line 3582 "ircd_parser.y"
7944	<	{
7945	<	ConfigFileEntry.oper_only_umodes |= UMODE_CCONN;
6182	>	case 596:
6183	>	#line 2693 "conf_parser.y"
6184	>	{
6185	>	ConfigGeneral.oper_only_umodes |= UMODE_EXTERNAL;
6186		}
6187	+	#line 6188 "conf_parser.c"
6188		break;
6189
6190	<	case 637:
6191	<
6192	<	/* Line 1455 of yacc.c  */
6193	<	#line 3585 "ircd_parser.y"
7953	<	{
7954	<	ConfigFileEntry.oper_only_umodes |= UMODE_CCONN_FULL;
6190	>	case 597:
6191	>	#line 2696 "conf_parser.y"
6192	>	{
6193	>	ConfigGeneral.oper_only_umodes |= UMODE_SERVNOTICE;
6194		}
6195	+	#line 6196 "conf_parser.c"
6196		break;
6197
6198	<	case 638:
6199	<
6200	<	/* Line 1455 of yacc.c  */
6201	<	#line 3588 "ircd_parser.y"
7962	<	{
7963	<	ConfigFileEntry.oper_only_umodes |= UMODE_DEAF;
6198	>	case 598:
6199	>	#line 2699 "conf_parser.y"
6200	>	{
6201	>	ConfigGeneral.oper_only_umodes |= UMODE_INVISIBLE;
6202		}
6203	+	#line 6204 "conf_parser.c"
6204		break;
6205
6206	<	case 639:
6207	<
6208	<	/* Line 1455 of yacc.c  */
6209	<	#line 3591 "ircd_parser.y"
7971	<	{
7972	<	ConfigFileEntry.oper_only_umodes |= UMODE_DEBUG;
6206	>	case 599:
6207	>	#line 2702 "conf_parser.y"
6208	>	{
6209	>	ConfigGeneral.oper_only_umodes |= UMODE_WALLOP;
6210		}
6211	+	#line 6212 "conf_parser.c"
6212		break;
6213
6214	<	case 640:
6215	<
6216	<	/* Line 1455 of yacc.c  */
6217	<	#line 3594 "ircd_parser.y"
7980	<	{
7981	<	ConfigFileEntry.oper_only_umodes |= UMODE_FULL;
6214	>	case 600:
6215	>	#line 2705 "conf_parser.y"
6216	>	{
6217	>	ConfigGeneral.oper_only_umodes |= UMODE_SOFTCALLERID;
6218		}
6219	+	#line 6220 "conf_parser.c"
6220		break;
6221
6222	<	case 641:
6223	<
6224	<	/* Line 1455 of yacc.c  */
6225	<	#line 3597 "ircd_parser.y"
7989	<	{
7990	<	ConfigFileEntry.oper_only_umodes |= UMODE_SKILL;
6222	>	case 601:
6223	>	#line 2708 "conf_parser.y"
6224	>	{
6225	>	ConfigGeneral.oper_only_umodes |= UMODE_CALLERID;
6226		}
6227	+	#line 6228 "conf_parser.c"
6228		break;
6229
6230	<	case 642:
6231	<
6232	<	/* Line 1455 of yacc.c  */
6233	<	#line 3600 "ircd_parser.y"
7998	<	{
7999	<	ConfigFileEntry.oper_only_umodes |= UMODE_NCHANGE;
6230	>	case 602:
6231	>	#line 2711 "conf_parser.y"
6232	>	{
6233	>	ConfigGeneral.oper_only_umodes |= UMODE_LOCOPS;
6234		}
6235	+	#line 6236 "conf_parser.c"
6236		break;
6237
6238	<	case 643:
6239	<
6240	<	/* Line 1455 of yacc.c  */
6241	<	#line 3603 "ircd_parser.y"
8007	<	{
8008	<	ConfigFileEntry.oper_only_umodes |= UMODE_REJ;
6238	>	case 603:
6239	>	#line 2714 "conf_parser.y"
6240	>	{
6241	>	ConfigGeneral.oper_only_umodes |= UMODE_REGONLY;
6242		}
6243	+	#line 6244 "conf_parser.c"
6244		break;
6245
6246	<	case 644:
6247	<
6248	<	/* Line 1455 of yacc.c  */
6249	<	#line 3606 "ircd_parser.y"
8016	<	{
8017	<	ConfigFileEntry.oper_only_umodes |= UMODE_UNAUTH;
6246	>	case 604:
6247	>	#line 2717 "conf_parser.y"
6248	>	{
6249	>	ConfigGeneral.oper_only_umodes |= UMODE_FARCONNECT;
6250		}
6251	+	#line 6252 "conf_parser.c"
6252		break;
6253
6254	<	case 645:
6255	<
6256	<	/* Line 1455 of yacc.c  */
6257	<	#line 3609 "ircd_parser.y"
8025	<	{
8026	<	ConfigFileEntry.oper_only_umodes |= UMODE_SPY;
6254	>	case 605:
6255	>	#line 2720 "conf_parser.y"
6256	>	{
6257	>	ConfigGeneral.oper_only_umodes |= UMODE_EXPIRATION;
6258		}
6259	+	#line 6260 "conf_parser.c"
6260		break;
6261
6262	<	case 646:
6263	<
6264	<	/* Line 1455 of yacc.c  */
6265	<	#line 3612 "ircd_parser.y"
8034	<	{
8035	<	ConfigFileEntry.oper_only_umodes |= UMODE_EXTERNAL;
6262	>	case 606:
6263	>	#line 2725 "conf_parser.y"
6264	>	{
6265	>	ConfigGeneral.min_nonwildcard = (yyvsp[-1].number);
6266		}
6267	+	#line 6268 "conf_parser.c"
6268		break;
6269
6270	<	case 647:
6271	<
6272	<	/* Line 1455 of yacc.c  */
6273	<	#line 3615 "ircd_parser.y"
8043	<	{
8044	<	ConfigFileEntry.oper_only_umodes |= UMODE_OPERWALL;
6270	>	case 607:
6271	>	#line 2730 "conf_parser.y"
6272	>	{
6273	>	ConfigGeneral.min_nonwildcard_simple = (yyvsp[-1].number);
6274		}
6275	+	#line 6276 "conf_parser.c"
6276		break;
6277
6278	<	case 648:
6279	<
6280	<	/* Line 1455 of yacc.c  */
6281	<	#line 3618 "ircd_parser.y"
8052	<	{
8053	<	ConfigFileEntry.oper_only_umodes |= UMODE_SERVNOTICE;
6278	>	case 608:
6279	>	#line 2735 "conf_parser.y"
6280	>	{
6281	>	ConfigGeneral.default_floodcount = (yyvsp[-1].number);
6282		}
6283	+	#line 6284 "conf_parser.c"
6284		break;
6285
6286	<	case 649:
6287	<
6288	<	/* Line 1455 of yacc.c  */
6289	<	#line 3621 "ircd_parser.y"
8061	<	{
8062	<	ConfigFileEntry.oper_only_umodes |= UMODE_INVISIBLE;
6286	>	case 609:
6287	>	#line 2740 "conf_parser.y"
6288	>	{
6289	>	ConfigGeneral.default_floodtime = (yyvsp[-1].number);
6290		}
6291	+	#line 6292 "conf_parser.c"
6292		break;
6293
6294	<	case 650:
6295	<
6296	<	/* Line 1455 of yacc.c  */
6297	<	#line 3624 "ircd_parser.y"
8070	<	{
8071	<	ConfigFileEntry.oper_only_umodes |= UMODE_WALLOP;
6294	>	case 629:
6295	>	#line 2769 "conf_parser.y"
6296	>	{
6297	>	ConfigChannel.enable_extbans = yylval.number;
6298		}
6299	+	#line 6300 "conf_parser.c"
6300		break;
6301
6302	<	case 651:
6303	<
6304	<	/* Line 1455 of yacc.c  */
6305	<	#line 3627 "ircd_parser.y"
8079	<	{
8080	<	ConfigFileEntry.oper_only_umodes |= UMODE_SOFTCALLERID;
6302	>	case 630:
6303	>	#line 2774 "conf_parser.y"
6304	>	{
6305	>	ConfigChannel.disable_fake_channels = yylval.number;
6306		}
6307	+	#line 6308 "conf_parser.c"
6308		break;
6309
6310	<	case 652:
6311	<
6312	<	/* Line 1455 of yacc.c  */
6313	<	#line 3630 "ircd_parser.y"
8088	<	{
8089	<	ConfigFileEntry.oper_only_umodes |= UMODE_CALLERID;
6310	>	case 631:
6311	>	#line 2779 "conf_parser.y"
6312	>	{
6313	>	ConfigChannel.invite_client_count = (yyvsp[-1].number);
6314		}
6315	+	#line 6316 "conf_parser.c"
6316		break;
6317
6318	<	case 653:
6319	<
6320	<	/* Line 1455 of yacc.c  */
6321	<	#line 3633 "ircd_parser.y"
8097	<	{
8098	<	ConfigFileEntry.oper_only_umodes |= UMODE_LOCOPS;
6318	>	case 632:
6319	>	#line 2784 "conf_parser.y"
6320	>	{
6321	>	ConfigChannel.invite_client_time = (yyvsp[-1].number);
6322		}
6323	+	#line 6324 "conf_parser.c"
6324		break;
6325
6326	<	case 654:
6327	<
6328	<	/* Line 1455 of yacc.c  */
6329	<	#line 3638 "ircd_parser.y"
8106	<	{
8107	<	ConfigFileEntry.min_nonwildcard = (yyvsp[(3) - (4)].number);
6326	>	case 633:
6327	>	#line 2789 "conf_parser.y"
6328	>	{
6329	>	ConfigChannel.invite_delay_channel = (yyvsp[-1].number);
6330		}
6331	+	#line 6332 "conf_parser.c"
6332		break;
6333
6334	<	case 655:
6335	<
6336	<	/* Line 1455 of yacc.c  */
6337	<	#line 3643 "ircd_parser.y"
8115	<	{
8116	<	ConfigFileEntry.min_nonwildcard_simple = (yyvsp[(3) - (4)].number);
6334	>	case 634:
6335	>	#line 2794 "conf_parser.y"
6336	>	{
6337	>	ConfigChannel.invite_expire_time = (yyvsp[-1].number);
6338		}
6339	+	#line 6340 "conf_parser.c"
6340		break;
6341
6342	<	case 656:
6343	<
6344	<	/* Line 1455 of yacc.c  */
6345	<	#line 3648 "ircd_parser.y"
8124	<	{
8125	<	ConfigFileEntry.default_floodcount = (yyvsp[(3) - (4)].number);
6342	>	case 635:
6343	>	#line 2799 "conf_parser.y"
6344	>	{
6345	>	ConfigChannel.knock_client_count = (yyvsp[-1].number);
6346		}
6347	+	#line 6348 "conf_parser.c"
6348		break;
6349
6350	<	case 657:
6351	<
6352	<	/* Line 1455 of yacc.c  */
6353	<	#line 3653 "ircd_parser.y"
8133	<	{
8134	<	ConfigFileEntry.client_flood = (yyvsp[(3) - (4)].number);
6350	>	case 636:
6351	>	#line 2804 "conf_parser.y"
6352	>	{
6353	>	ConfigChannel.knock_client_time = (yyvsp[-1].number);
6354		}
6355	+	#line 6356 "conf_parser.c"
6356		break;
6357
6358	<	case 658:
6359	<
6360	<	/* Line 1455 of yacc.c  */
6361	<	#line 3658 "ircd_parser.y"
8142	<	{
8143	<	ConfigFileEntry.dot_in_ip6_addr = yylval.number;
6358	>	case 637:
6359	>	#line 2809 "conf_parser.y"
6360	>	{
6361	>	ConfigChannel.knock_delay_channel = (yyvsp[-1].number);
6362		}
6363	+	#line 6364 "conf_parser.c"
6364		break;
6365
6366	<	case 659:
6367	<
6368	<	/* Line 1455 of yacc.c  */
6369	<	#line 3666 "ircd_parser.y"
8151	<	{
8152	<	if (conf_parser_ctx.pass == 2)
8153	<	{
8154	<	yy_conf = make_conf_item(GDENY_TYPE);
8155	<	yy_aconf = map_to_conf(yy_conf);
8156	<	}
6366	>	case 638:
6367	>	#line 2814 "conf_parser.y"
6368	>	{
6369	>	ConfigChannel.max_channels = (yyvsp[-1].number);
6370		}
6371	+	#line 6372 "conf_parser.c"
6372		break;
6373
6374	<	case 660:
6375	<
6376	<	/* Line 1455 of yacc.c  */
6377	<	#line 3673 "ircd_parser.y"
8164	<	{
8165	<	if (conf_parser_ctx.pass == 2)
8166	<	{
8167	<	/*
8168	<	* since we re-allocate yy_conf/yy_aconf after the end of action=, at the
8169	<	* end we will have one extra, so we should free it.
8170	<	*/
8171	<	if (yy_conf->name == NULL || yy_aconf->user == NULL)
8172	<	{
8173	<	delete_conf_item(yy_conf);
8174	<	yy_conf = NULL;
8175	<	yy_aconf = NULL;
8176	<	}
8177	<	}
6374	>	case 639:
6375	>	#line 2819 "conf_parser.y"
6376	>	{
6377	>	ConfigChannel.max_invites = (yyvsp[-1].number);
6378		}
6379	+	#line 6380 "conf_parser.c"
6380		break;
6381
6382	<	case 670:
6383	<
6384	<	/* Line 1455 of yacc.c  */
6385	<	#line 3699 "ircd_parser.y"
8185	<	{
8186	<	if (conf_parser_ctx.pass == 2)
8187	<	ConfigFileEntry.glines = yylval.number;
6382	>	case 640:
6383	>	#line 2824 "conf_parser.y"
6384	>	{
6385	>	ConfigChannel.max_bans = (yyvsp[-1].number);
6386		}
6387	+	#line 6388 "conf_parser.c"
6388		break;
6389
6390	<	case 671:
6391	<
6392	<	/* Line 1455 of yacc.c  */
6393	<	#line 3705 "ircd_parser.y"
8195	<	{
8196	<	if (conf_parser_ctx.pass == 2)
8197	<	ConfigFileEntry.gline_time = (yyvsp[(3) - (4)].number);
6390	>	case 641:
6391	>	#line 2829 "conf_parser.y"
6392	>	{
6393	>	ConfigChannel.max_bans_large = (yyvsp[-1].number);
6394		}
6395	+	#line 6396 "conf_parser.c"
6396		break;
6397
6398	<	case 672:
6399	<
6400	<	/* Line 1455 of yacc.c  */
6401	<	#line 3711 "ircd_parser.y"
8205	<	{
8206	<	if (conf_parser_ctx.pass == 2)
8207	<	ConfigFileEntry.gline_logging = 0;
6398	>	case 642:
6399	>	#line 2834 "conf_parser.y"
6400	>	{
6401	>	ConfigChannel.default_join_flood_count = yylval.number;
6402		}
6403	+	#line 6404 "conf_parser.c"
6404		break;
6405
6406	<	case 676:
6407	<
6408	<	/* Line 1455 of yacc.c  */
6409	<	#line 3717 "ircd_parser.y"
8215	<	{
8216	<	if (conf_parser_ctx.pass == 2)
8217	<	ConfigFileEntry.gline_logging |= GDENY_REJECT;
6406	>	case 643:
6407	>	#line 2839 "conf_parser.y"
6408	>	{
6409	>	ConfigChannel.default_join_flood_time = (yyvsp[-1].number);
6410		}
6411	+	#line 6412 "conf_parser.c"
6412		break;
6413
6414	<	case 677:
6415	<
6416	<	/* Line 1455 of yacc.c  */
8224	<	#line 3721 "ircd_parser.y"
8225	<	{
6414	>	case 657:
6415	>	#line 2862 "conf_parser.y"
6416	>	{
6417		if (conf_parser_ctx.pass == 2)
6418	<	ConfigFileEntry.gline_logging |= GDENY_BLOCK;
6418	>	ConfigServerHide.flatten_links = yylval.number;
6419		}
6420	+	#line 6421 "conf_parser.c"
6421		break;
6422
6423	<	case 678:
6424	<
6425	<	/* Line 1455 of yacc.c  */
8234	<	#line 3727 "ircd_parser.y"
8235	<	{
6423	>	case 658:
6424	>	#line 2868 "conf_parser.y"
6425	>	{
6426		if (conf_parser_ctx.pass == 2)
6427		{
6428	<	struct split_nuh_item nuh;
8239	<
8240	<	nuh.nuhmask  = yylval.string;
8241	<	nuh.nickptr  = NULL;
8242	<	nuh.userptr  = userbuf;
8243	<	nuh.hostptr  = hostbuf;
8244	<
8245	<	nuh.nicksize = 0;
8246	<	nuh.usersize = sizeof(userbuf);
8247	<	nuh.hostsize = sizeof(hostbuf);
8248	<
8249	<	split_nuh(&nuh);
8250	<
8251	<	if (yy_aconf->user == NULL)
6428	>	if ((yyvsp[-1].number) > 0)
6429		{
6430	<	DupString(yy_aconf->user, userbuf);
6431	<	DupString(yy_aconf->host, hostbuf);
6430	>	event_write_links_file.when = (yyvsp[-1].number);
6431	>	event_add(&event_write_links_file, NULL);
6432		}
6433		else
6434	<	{
8258	<	struct CollectItem *yy_tmp = MyMalloc(sizeof(struct CollectItem));
8259	<
8260	<	DupString(yy_tmp->user, userbuf);
8261	<	DupString(yy_tmp->host, hostbuf);
8262	<
8263	<	dlinkAdd(yy_tmp, &yy_tmp->node, &col_conf_list);
8264	<	}
8265	<	}
8266	<	}
8267	<	break;
6434	>	event_delete(&event_write_links_file);
6435
6436	<	case 679:
8270	<
8271	<	/* Line 1455 of yacc.c  */
8272	<	#line 3761 "ircd_parser.y"
8273	<	{
8274	<	if (conf_parser_ctx.pass == 2)
8275	<	{
8276	<	MyFree(yy_conf->name);
8277	<	DupString(yy_conf->name, yylval.string);
6436	>	ConfigServerHide.flatten_links_delay = (yyvsp[-1].number);
6437		}
6438		}
6439	+	#line 6440 "conf_parser.c"
6440		break;
6441
6442	<	case 680:
6443	<
6444	<	/* Line 1455 of yacc.c  */
8285	<	#line 3770 "ircd_parser.y"
8286	<	{
8287	<	if (conf_parser_ctx.pass == 2)
8288	<	yy_aconf->flags = 0;
8289	<	}
8290	<	break;
8291	<
8292	<	case 681:
8293	<
8294	<	/* Line 1455 of yacc.c  */
8295	<	#line 3774 "ircd_parser.y"
8296	<	{
6442	>	case 659:
6443	>	#line 2884 "conf_parser.y"
6444	>	{
6445		if (conf_parser_ctx.pass == 2)
6446		{
6447	<	struct CollectItem *yy_tmp = NULL;
6448	<	dlink_node *ptr, *next_ptr;
8301	<
8302	<	DLINK_FOREACH_SAFE(ptr, next_ptr, col_conf_list.head)
8303	<	{
8304	<	struct AccessItem *new_aconf;
8305	<	struct ConfItem *new_conf;
8306	<
8307	<	yy_tmp = ptr->data;
8308	<	new_conf = make_conf_item(GDENY_TYPE);
8309	<	new_aconf = map_to_conf(new_conf);
8310	<
8311	<	new_aconf->flags = yy_aconf->flags;
8312	<
8313	<	if (yy_conf->name != NULL)
8314	<	DupString(new_conf->name, yy_conf->name);
8315	<	else
8316	<	DupString(new_conf->name, "*");
8317	<	if (yy_aconf->user != NULL)
8318	<	DupString(new_aconf->user, yy_tmp->user);
8319	<	else
8320	<	DupString(new_aconf->user, "*");
8321	<	if (yy_aconf->host != NULL)
8322	<	DupString(new_aconf->host, yy_tmp->host);
8323	<	else
8324	<	DupString(new_aconf->host, "*");
8325	<
8326	<	dlinkDelete(&yy_tmp->node, &col_conf_list);
8327	<	}
8328	<
8329	<	/*
8330	<	* In case someone has fed us with more than one action= after user/name
8331	<	* which would leak memory  -Michael
8332	<	*/
8333	<	if (yy_conf->name == NULL || yy_aconf->user == NULL)
8334	<	delete_conf_item(yy_conf);
8335	<
8336	<	yy_conf = make_conf_item(GDENY_TYPE);
8337	<	yy_aconf = map_to_conf(yy_conf);
6447	>	xfree(ConfigServerHide.flatten_links_file);
6448	>	ConfigServerHide.flatten_links_file = xstrdup(yylval.string);
6449		}
6450		}
6451	+	#line 6452 "conf_parser.c"
6452		break;
6453
6454	<	case 684:
6455	<
6456	<	/* Line 1455 of yacc.c  */
8345	<	#line 3821 "ircd_parser.y"
8346	<	{
8347	<	if (conf_parser_ctx.pass == 2)
8348	<	yy_aconf->flags |= GDENY_REJECT;
8349	<	}
8350	<	break;
8351	<
8352	<	case 685:
8353	<
8354	<	/* Line 1455 of yacc.c  */
8355	<	#line 3825 "ircd_parser.y"
8356	<	{
8357	<	if (conf_parser_ctx.pass == 2)
8358	<	yy_aconf->flags |= GDENY_BLOCK;
8359	<	}
8360	<	break;
8361	<
8362	<	case 708:
8363	<
8364	<	/* Line 1455 of yacc.c  */
8365	<	#line 3849 "ircd_parser.y"
8366	<	{
8367	<	ConfigChannel.disable_fake_channels = yylval.number;
8368	<	}
8369	<	break;
8370	<
8371	<	case 709:
8372	<
8373	<	/* Line 1455 of yacc.c  */
8374	<	#line 3854 "ircd_parser.y"
8375	<	{
8376	<	ConfigChannel.restrict_channels = yylval.number;
8377	<	}
8378	<	break;
8379	<
8380	<	case 710:
8381	<
8382	<	/* Line 1455 of yacc.c  */
8383	<	#line 3859 "ircd_parser.y"
8384	<	{
8385	<	ConfigChannel.disable_local_channels = yylval.number;
8386	<	}
8387	<	break;
8388	<
8389	<	case 711:
8390	<
8391	<	/* Line 1455 of yacc.c  */
8392	<	#line 3864 "ircd_parser.y"
8393	<	{
8394	<	ConfigChannel.use_except = yylval.number;
8395	<	}
8396	<	break;
8397	<
8398	<	case 712:
8399	<
8400	<	/* Line 1455 of yacc.c  */
8401	<	#line 3869 "ircd_parser.y"
8402	<	{
8403	<	ConfigChannel.use_invex = yylval.number;
8404	<	}
8405	<	break;
8406	<
8407	<	case 713:
8408	<
8409	<	/* Line 1455 of yacc.c  */
8410	<	#line 3874 "ircd_parser.y"
8411	<	{
8412	<	ConfigChannel.use_knock = yylval.number;
8413	<	}
8414	<	break;
8415	<
8416	<	case 714:
8417	<
8418	<	/* Line 1455 of yacc.c  */
8419	<	#line 3879 "ircd_parser.y"
8420	<	{
8421	<	ConfigChannel.knock_delay = (yyvsp[(3) - (4)].number);
8422	<	}
8423	<	break;
8424	<
8425	<	case 715:
8426	<
8427	<	/* Line 1455 of yacc.c  */
8428	<	#line 3884 "ircd_parser.y"
8429	<	{
8430	<	ConfigChannel.knock_delay_channel = (yyvsp[(3) - (4)].number);
8431	<	}
8432	<	break;
8433	<
8434	<	case 716:
8435	<
8436	<	/* Line 1455 of yacc.c  */
8437	<	#line 3889 "ircd_parser.y"
8438	<	{
8439	<	ConfigChannel.max_chans_per_user = (yyvsp[(3) - (4)].number);
8440	<	}
8441	<	break;
8442	<
8443	<	case 717:
8444	<
8445	<	/* Line 1455 of yacc.c  */
8446	<	#line 3894 "ircd_parser.y"
8447	<	{
8448	<	ConfigChannel.quiet_on_ban = yylval.number;
8449	<	}
8450	<	break;
8451	<
8452	<	case 718:
8453	<
8454	<	/* Line 1455 of yacc.c  */
8455	<	#line 3899 "ircd_parser.y"
8456	<	{
8457	<	ConfigChannel.max_bans = (yyvsp[(3) - (4)].number);
8458	<	}
8459	<	break;
8460	<
8461	<	case 719:
8462	<
8463	<	/* Line 1455 of yacc.c  */
8464	<	#line 3904 "ircd_parser.y"
8465	<	{
8466	<	ConfigChannel.default_split_user_count = (yyvsp[(3) - (4)].number);
8467	<	}
8468	<	break;
8469	<
8470	<	case 720:
8471	<
8472	<	/* Line 1455 of yacc.c  */
8473	<	#line 3909 "ircd_parser.y"
8474	<	{
8475	<	ConfigChannel.default_split_server_count = (yyvsp[(3) - (4)].number);
8476	<	}
8477	<	break;
8478	<
8479	<	case 721:
8480	<
8481	<	/* Line 1455 of yacc.c  */
8482	<	#line 3914 "ircd_parser.y"
8483	<	{
8484	<	ConfigChannel.no_create_on_split = yylval.number;
8485	<	}
8486	<	break;
8487	<
8488	<	case 722:
8489	<
8490	<	/* Line 1455 of yacc.c  */
8491	<	#line 3919 "ircd_parser.y"
8492	<	{
8493	<	ConfigChannel.no_join_on_split = yylval.number;
8494	<	}
8495	<	break;
8496	<
8497	<	case 723:
8498	<
8499	<	/* Line 1455 of yacc.c  */
8500	<	#line 3924 "ircd_parser.y"
8501	<	{
8502	<	ConfigChannel.burst_topicwho = yylval.number;
8503	<	}
8504	<	break;
8505	<
8506	<	case 724:
8507	<
8508	<	/* Line 1455 of yacc.c  */
8509	<	#line 3929 "ircd_parser.y"
8510	<	{
8511	<	GlobalSetOptions.joinfloodcount = yylval.number;
8512	<	}
8513	<	break;
8514	<
8515	<	case 725:
8516	<
8517	<	/* Line 1455 of yacc.c  */
8518	<	#line 3934 "ircd_parser.y"
8519	<	{
8520	<	GlobalSetOptions.joinfloodtime = yylval.number;
8521	<	}
8522	<	break;
8523	<
8524	<	case 737:
8525	<
8526	<	/* Line 1455 of yacc.c  */
8527	<	#line 3953 "ircd_parser.y"
8528	<	{
6454	>	case 660:
6455	>	#line 2893 "conf_parser.y"
6456	>	{
6457		if (conf_parser_ctx.pass == 2)
6458	<	ConfigServerHide.flatten_links = yylval.number;
6458	>	ConfigServerHide.disable_remote_commands = yylval.number;
6459		}
6460	+	#line 6461 "conf_parser.c"
6461		break;
6462
6463	<	case 738:
6464	<
6465	<	/* Line 1455 of yacc.c  */
8537	<	#line 3959 "ircd_parser.y"
8538	<	{
6463	>	case 661:
6464	>	#line 2899 "conf_parser.y"
6465	>	{
6466		if (conf_parser_ctx.pass == 2)
6467		ConfigServerHide.hide_servers = yylval.number;
6468		}
6469	+	#line 6470 "conf_parser.c"
6470		break;
6471
6472	<	case 739:
6473	<
6474	<	/* Line 1455 of yacc.c  */
8547	<	#line 3965 "ircd_parser.y"
8548	<	{
6472	>	case 662:
6473	>	#line 2905 "conf_parser.y"
6474	>	{
6475		if (conf_parser_ctx.pass == 2)
6476	<	{
8551	<	MyFree(ConfigServerHide.hidden_name);
8552	<	DupString(ConfigServerHide.hidden_name, yylval.string);
8553	<	}
6476	>	ConfigServerHide.hide_services = yylval.number;
6477		}
6478	+	#line 6479 "conf_parser.c"
6479		break;
6480
6481	<	case 740:
6482	<
6483	<	/* Line 1455 of yacc.c  */
8560	<	#line 3974 "ircd_parser.y"
8561	<	{
6481	>	case 663:
6482	>	#line 2911 "conf_parser.y"
6483	>	{
6484		if (conf_parser_ctx.pass == 2)
6485		{
6486	<	if (((yyvsp[(3) - (4)].number) > 0) && ConfigServerHide.links_disabled == 1)
6487	<	{
8566	<	eventAddIsh("write_links_file", write_links_file, NULL, (yyvsp[(3) - (4)].number));
8567	<	ConfigServerHide.links_disabled = 0;
8568	<	}
8569	<
8570	<	ConfigServerHide.links_delay = (yyvsp[(3) - (4)].number);
6486	>	xfree(ConfigServerHide.hidden_name);
6487	>	ConfigServerHide.hidden_name = xstrdup(yylval.string);
6488		}
6489		}
6490	+	#line 6491 "conf_parser.c"
6491		break;
6492
6493	<	case 741:
6494	<
6495	<	/* Line 1455 of yacc.c  */
8578	<	#line 3988 "ircd_parser.y"
8579	<	{
6493	>	case 664:
6494	>	#line 2920 "conf_parser.y"
6495	>	{
6496		if (conf_parser_ctx.pass == 2)
6497		ConfigServerHide.hidden = yylval.number;
6498		}
6499	+	#line 6500 "conf_parser.c"
6500		break;
6501
6502	<	case 742:
6503	<
6504	<	/* Line 1455 of yacc.c  */
8588	<	#line 3994 "ircd_parser.y"
8589	<	{
8590	<	if (conf_parser_ctx.pass == 2)
8591	<	ConfigServerHide.disable_hidden = yylval.number;
8592	<	}
8593	<	break;
8594	<
8595	<	case 743:
8596	<
8597	<	/* Line 1455 of yacc.c  */
8598	<	#line 4000 "ircd_parser.y"
8599	<	{
6502	>	case 665:
6503	>	#line 2926 "conf_parser.y"
6504	>	{
6505		if (conf_parser_ctx.pass == 2)
6506		ConfigServerHide.hide_server_ips = yylval.number;
6507		}
6508	+	#line 6509 "conf_parser.c"
6509		break;
6510
6511
6512	+	#line 6513 "conf_parser.c"
6513
8607	–	/* Line 1455 of yacc.c  */
8608	–	#line 8609 "ircd_parser.c"
6514		default: break;
6515		}
6516	+	/* User semantic actions sometimes alter yychar, and that requires
6517	+	that yytoken be updated with the new translation.  We take the
6518	+	approach of translating immediately before every use of yytoken.
6519	+	One alternative is translating here after every semantic action,
6520	+	but that translation would be missed if the semantic action invokes
6521	+	YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
6522	+	if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
6523	+	incorrect destructor might then be invoked immediately.  In the
6524	+	case of YYERROR or YYBACKUP, subsequent parser actions might lead
6525	+	to an incorrect destructor call or verbose syntax error message
6526	+	before the lookahead is translated.  */
6527		YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
6528
6529		YYPOPSTACK (yylen);
#	Line 8616 | Line 6532 | yyreduce:
6532
6533		*++yyvsp = yyval;
6534
6535	<	/* Now `shift' the result of the reduction.  Determine what state
6535	>	/* Now 'shift' the result of the reduction.  Determine what state
6536		that goes to, based on the state we popped back to and the rule
6537		number reduced by.  */
6538	<
6539	<	yyn = yyr1[yyn];
6540	<
6541	<	yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
6542	<	if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
6543	<	yystate = yytable[yystate];
6544	<	else
8629	<	yystate = yydefgoto[yyn - YYNTOKENS];
6538	>	{
6539	>	const int yylhs = yyr1[yyn] - YYNTOKENS;
6540	>	const int yyi = yypgoto[yylhs] + *yyssp;
6541	>	yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
6542	>	? yytable[yyi]
6543	>	: yydefgoto[yylhs]);
6544	>	}
6545
6546		goto yynewstate;
6547
6548
6549	<	/*------------------------------------.
6550	<	| yyerrlab -- here on detecting error |
6551	<	`------------------------------------*/
6549	>	/*--------------------------------------.
6550	>	| yyerrlab -- here on detecting error.  |
6551	>	`--------------------------------------*/
6552		yyerrlab:
6553	+	/* Make sure we have latest lookahead translation.  See comments at
6554	+	user semantic actions for why this is necessary.  */
6555	+	yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
6556	+
6557		/* If not already recovering from an error, report this error.  */
6558		if (!yyerrstatus)
6559		{
#	Line 8642 | Line 6561 | yyerrlab:
6561		#if ! YYERROR_VERBOSE
6562		yyerror (YY_("syntax error"));
6563		#else
6564	+	# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
6565	+	yyssp, yytoken)
6566		{
6567	<	YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
6568	<	if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
6569	<	{
6570	<	YYSIZE_T yyalloc = 2 * yysize;
6571	<	if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
6572	<	yyalloc = YYSTACK_ALLOC_MAXIMUM;
6573	<	if (yymsg != yymsgbuf)
6574	<	YYSTACK_FREE (yymsg);
6575	<	yymsg = (char *) YYSTACK_ALLOC (yyalloc);
6576	<	if (yymsg)
6577	<	yymsg_alloc = yyalloc;
6578	<	else
6579	<	{
6580	<	yymsg = yymsgbuf;
6581	<	yymsg_alloc = sizeof yymsgbuf;
6582	<	}
6583	<	}
6584	<
6585	<	if (0 < yysize && yysize <= yymsg_alloc)
6586	<	{
6587	<	(void) yysyntax_error (yymsg, yystate, yychar);
6588	<	yyerror (yymsg);
6589	<	}
6590	<	else
6591	<	{
8671	<	yyerror (YY_("syntax error"));
8672	<	if (yysize != 0)
8673	<	goto yyexhaustedlab;
8674	<	}
6567	>	char const *yymsgp = YY_("syntax error");
6568	>	int yysyntax_error_status;
6569	>	yysyntax_error_status = YYSYNTAX_ERROR;
6570	>	if (yysyntax_error_status == 0)
6571	>	yymsgp = yymsg;
6572	>	else if (yysyntax_error_status == 1)
6573	>	{
6574	>	if (yymsg != yymsgbuf)
6575	>	YYSTACK_FREE (yymsg);
6576	>	yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
6577	>	if (!yymsg)
6578	>	{
6579	>	yymsg = yymsgbuf;
6580	>	yymsg_alloc = sizeof yymsgbuf;
6581	>	yysyntax_error_status = 2;
6582	>	}
6583	>	else
6584	>	{
6585	>	yysyntax_error_status = YYSYNTAX_ERROR;
6586	>	yymsgp = yymsg;
6587	>	}
6588	>	}
6589	>	yyerror (yymsgp);
6590	>	if (yysyntax_error_status == 2)
6591	>	goto yyexhaustedlab;
6592		}
6593	+	# undef YYSYNTAX_ERROR
6594		#endif
6595		}
6596
#	Line 8681 | Line 6599 | yyerrlab:
6599		if (yyerrstatus == 3)
6600		{
6601		/* If just tried and failed to reuse lookahead token after an
6602	<	error, discard it.  */
6602	>	error, discard it.  */
6603
6604		if (yychar <= YYEOF)
6605	<	{
6606	<	/* Return failure if at end of input.  */
6607	<	if (yychar == YYEOF)
6608	<	YYABORT;
6609	<	}
6605	>	{
6606	>	/* Return failure if at end of input.  */
6607	>	if (yychar == YYEOF)
6608	>	YYABORT;
6609	>	}
6610		else
6611	<	{
6612	<	yydestruct ("Error: discarding",
6613	<	yytoken, &yylval);
6614	<	yychar = YYEMPTY;
6615	<	}
6611	>	{
6612	>	yydestruct ("Error: discarding",
6613	>	yytoken, &yylval);
6614	>	yychar = YYEMPTY;
6615	>	}
6616		}
6617
6618		/* Else will try to reuse lookahead token after shifting the error
#	Line 8706 | Line 6624 | yyerrlab:
6624		| yyerrorlab -- error raised explicitly by YYERROR.  |
6625		`---------------------------------------------------*/
6626		yyerrorlab:
6627	+	/* Pacify compilers when the user code never invokes YYERROR and the
6628	+	label yyerrorlab therefore never appears in user code.  */
6629	+	if (0)
6630	+	YYERROR;
6631
6632	<	/* Pacify compilers like GCC when the user code never invokes
8711	<	YYERROR and the label yyerrorlab therefore never appears in user
8712	<	code.  */
8713	<	if (/*CONSTCOND*/ 0)
8714	<	goto yyerrorlab;
8715	<
8716	<	/* Do not reclaim the symbols of the rule which action triggered
6632	>	/* Do not reclaim the symbols of the rule whose action triggered
6633		this YYERROR.  */
6634		YYPOPSTACK (yylen);
6635		yylen = 0;
#	Line 8726 | Line 6642 | yyerrorlab:
6642		| yyerrlab1 -- common code for both syntax error and YYERROR.  |
6643		`-------------------------------------------------------------*/
6644		yyerrlab1:
6645	<	yyerrstatus = 3;      /* Each real token shifted decrements this.  */
6645	>	yyerrstatus = 3;      /* Each real token shifted decrements this.  */
6646
6647		for (;;)
6648		{
6649		yyn = yypact[yystate];
6650	<	if (yyn != YYPACT_NINF)
6651	<	{
6652	<	yyn += YYTERROR;
6653	<	if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
6654	<	{
6655	<	yyn = yytable[yyn];
6656	<	if (0 < yyn)
6657	<	break;
6658	<	}
6659	<	}
6650	>	if (!yypact_value_is_default (yyn))
6651	>	{
6652	>	yyn += YYTERROR;
6653	>	if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
6654	>	{
6655	>	yyn = yytable[yyn];
6656	>	if (0 < yyn)
6657	>	break;
6658	>	}
6659	>	}
6660
6661		/* Pop the current state because it cannot handle the error token.  */
6662		if (yyssp == yyss)
6663	<	YYABORT;
6663	>	YYABORT;
6664
6665
6666		yydestruct ("Error: popping",
6667	<	yystos[yystate], yyvsp);
6667	>	yystos[yystate], yyvsp);
6668		YYPOPSTACK (1);
6669		yystate = *yyssp;
6670		YY_STACK_PRINT (yyss, yyssp);
6671		}
6672
6673	+	YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
6674		*++yyvsp = yylval;
6675	+	YY_IGNORE_MAYBE_UNINITIALIZED_END
6676
6677
6678		/* Shift the error token.  */
#	Line 8771 | Line 6689 | yyacceptlab:
6689		yyresult = 0;
6690		goto yyreturn;
6691
6692	+
6693		/*-----------------------------------.
6694		| yyabortlab -- YYABORT comes here.  |
6695		`-----------------------------------*/
#	Line 8778 | Line 6697 | yyabortlab:
6697		yyresult = 1;
6698		goto yyreturn;
6699
6700	<	#if !defined(yyoverflow) || YYERROR_VERBOSE
6700	>
6701	>	#if !defined yyoverflow || YYERROR_VERBOSE
6702		/*-------------------------------------------------.
6703		| yyexhaustedlab -- memory exhaustion comes here.  |
6704		`-------------------------------------------------*/
#	Line 8788 | Line 6708 | yyexhaustedlab:
6708		/* Fall through.  */
6709		#endif
6710
6711	+
6712	+	/*-----------------------------------------------------.
6713	+	| yyreturn -- parsing is finished, return the result.  |
6714	+	`-----------------------------------------------------*/
6715		yyreturn:
6716		if (yychar != YYEMPTY)
6717	<	yydestruct ("Cleanup: discarding lookahead",
6718	<	yytoken, &yylval);
6719	<	/* Do not reclaim the symbols of the rule which action triggered
6717	>	{
6718	>	/* Make sure we have latest lookahead translation.  See comments at
6719	>	user semantic actions for why this is necessary.  */
6720	>	yytoken = YYTRANSLATE (yychar);
6721	>	yydestruct ("Cleanup: discarding lookahead",
6722	>	yytoken, &yylval);
6723	>	}
6724	>	/* Do not reclaim the symbols of the rule whose action triggered
6725		this YYABORT or YYACCEPT.  */
6726		YYPOPSTACK (yylen);
6727		YY_STACK_PRINT (yyss, yyssp);
6728		while (yyssp != yyss)
6729		{
6730		yydestruct ("Cleanup: popping",
6731	<	yystos[*yyssp], yyvsp);
6731	>	yystos[+*yyssp], yyvsp);
6732		YYPOPSTACK (1);
6733		}
6734		#ifndef yyoverflow
#	Line 8810 | Line 6739 | yyreturn:
6739		if (yymsg != yymsgbuf)
6740		YYSTACK_FREE (yymsg);
6741		#endif
6742	<	/* Make sure YYID is used.  */
8814	<	return YYID (yyresult);
6742	>	return yyresult;
6743		}
8816	–
8817	–
8818	–

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)