initial importHEADmain

1 files changed, 15927 insertions, 0 deletions

diff --git a/tool_src/QvLib/QvTraverse.p b/tool_src/QvLib/QvTraverse.p
new file mode 100644
index 0000000..15aa9ae
--- /dev/null
+++ b/tool_src/QvLib/QvTraverse.p
@@ -0,0 +1,15927 @@
+# 1 "QvTraverse.cpp"
+# 1 "QvElement.h" 1
+
+
+
+# 1 "QvBasic.h" 1
+
+
+
+
+
+
+
+
+
+# 1 "/usr/include/sys/types.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/usr/include/sys/cdefs.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 121 "/usr/include/sys/cdefs.h" 3 4
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 67 "/usr/include/sys/types.h" 2 3 4
+
+
+ 
+# 1 "/usr/include/machine/types.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+# 1 "/usr/include/ppc/types.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+typedef	signed  char		int8_t;
+typedef	unsigned char		u_int8_t;
+typedef	short			int16_t;
+typedef	unsigned short		u_int16_t;
+typedef	int			int32_t;
+typedef	unsigned int		u_int32_t;
+typedef	long long		int64_t;
+typedef	unsigned long long	u_int64_t;
+
+typedef int32_t			register_t;
+
+
+typedef int 			*intptr_t;
+typedef unsigned long		*uintptr_t;
+
+
+
+# 30 "/usr/include/machine/types.h" 2 3 4
+
+
+
+
+
+
+
+
+
+# 70 "/usr/include/sys/types.h" 2 3 4
+
+
+# 1 "/usr/include/machine/ansi.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+# 1 "/usr/include/ppc/ansi.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 34 "/usr/include/machine/ansi.h" 2 3 4
+
+
+
+
+
+
+
+
+
+# 72 "/usr/include/sys/types.h" 2 3 4
+
+# 1 "/usr/include/machine/endian.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+# 1 "/usr/include/ppc/endian.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+extern "C" { 
+unsigned long	htonl  (unsigned long)  ;
+unsigned short	htons  (unsigned short)  ;
+unsigned long	ntohl  (unsigned long)  ;
+unsigned short	ntohs  (unsigned short)  ;
+} 
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 116 "/usr/include/ppc/endian.h" 3 4
+
+
+
+# 30 "/usr/include/machine/endian.h" 2 3 4
+
+
+
+
+
+
+
+
+
+# 73 "/usr/include/sys/types.h" 2 3 4
+
+
+
+typedef	unsigned char	u_char;
+typedef	unsigned short	u_short;
+typedef	unsigned int	u_int;
+typedef	unsigned long	u_long;
+typedef	unsigned short	ushort;		 
+typedef	unsigned int	uint;		 
+
+
+typedef	u_int64_t	u_quad_t;	 
+typedef	int64_t		quad_t;
+typedef	quad_t *	qaddr_t;
+
+typedef	char *		caddr_t;	 
+typedef	int32_t		daddr_t;	 
+typedef	int32_t		dev_t;		 
+typedef	u_int32_t	fixpt_t;	 
+typedef	u_int32_t	gid_t;		 
+typedef	u_int32_t	ino_t;		 
+typedef	long		key_t;		 
+typedef	u_int16_t	mode_t;		 
+typedef	u_int16_t	nlink_t;	 
+typedef	quad_t		off_t;		 
+typedef	int32_t		pid_t;		 
+typedef quad_t		rlim_t;		 
+typedef	int32_t		segsz_t;	 
+typedef	int32_t		swblk_t;	 
+typedef	u_int32_t	uid_t;		 
+
+
+
+ 
+
+
+
+
+
+
+
+typedef	unsigned long 	clock_t;
+
+
+
+
+typedef	long unsigned int 	size_t;
+
+
+
+
+typedef	int 	ssize_t;
+
+
+
+
+typedef	long 	time_t;
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+typedef int32_t	fd_mask;
+
+
+
+
+
+
+typedef	struct fd_set {
+	fd_mask	fds_bits[((( 256  ) + ((  (sizeof(fd_mask) * 8 )  ) - 1)) / (  (sizeof(fd_mask) * 8 )  )) ];
+} fd_set;
+
+
+
+
+
+
+
+# 174 "/usr/include/sys/types.h" 3 4
+
+
+
+
+
+struct _pthread_handler_rec
+{
+	void           (*routine)(void *);   
+	void           *arg;                  
+	struct _pthread_handler_rec *next;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+typedef struct _opaque_pthread_t { long sig; struct _pthread_handler_rec  *cleanup_stack; char opaque[596 ];} *pthread_t;
+
+typedef struct _opaque_pthread_attr_t { long sig; char opaque[36 ]; } pthread_attr_t;
+
+typedef struct _opaque_pthread_mutexattr_t { long sig; char opaque[8 ]; } pthread_mutexattr_t;
+
+typedef struct _opaque_pthread_mutex_t { long sig; char opaque[40 ]; } pthread_mutex_t;
+
+typedef struct _opaque_pthread_condattr_t { long sig; char opaque[4 ]; } pthread_condattr_t;
+
+typedef struct _opaque_pthread_cond_t { long sig;  char opaque[24 ]; } pthread_cond_t;
+
+typedef struct { long sig; char opaque[4 ]; } pthread_once_t;
+
+
+
+typedef unsigned long pthread_key_t;     
+
+
+# 10 "QvBasic.h" 2
+
+
+# 1 "/usr/include/libc.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+# 1 "/usr/include/stdio.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+typedef off_t fpos_t;
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+ 
+struct __sbuf {
+	unsigned char *_base;
+	int	_size;
+};
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef	struct __sFILE {
+	unsigned char *_p;	 
+	int	_r;		 
+	int	_w;		 
+	short	_flags;		 
+	short	_file;		 
+	struct	__sbuf _bf;	 
+	int	_lbfsize;	 
+
+	 
+	void	*_cookie;	 
+	int	(*_close)  (void *)  ;
+	int	(*_read)   (void *, char *, int)  ;
+	fpos_t	(*_seek)   (void *, fpos_t, int)  ;
+	int	(*_write)  (void *, const char *, int)  ;
+
+	 
+	struct	__sbuf _ub;	 
+	unsigned char *_up;	 
+	int	_ur;		 
+
+	 
+	unsigned char _ubuf[3];	 
+	unsigned char _nbuf[1];	 
+
+	 
+	struct	__sbuf _lb;	 
+
+	 
+	int	_blksize;	 
+	fpos_t	_offset;	 
+} FILE;
+
+extern "C" { 
+extern FILE __sF[];
+} 
+
+
+
+
+
+	 
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+				 
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+extern "C" { 
+void	 clearerr  (FILE *)  ;
+int	 fclose  (FILE *)  ;
+int	 feof  (FILE *)  ;
+int	 ferror  (FILE *)  ;
+int	 fflush  (FILE *)  ;
+int	 fgetc  (FILE *)  ;
+int	 fgetpos  (FILE *, fpos_t *)  ;
+char	*fgets  (char *, size_t, FILE *)  ;
+FILE	*fopen  (const char *, const char *)  ;
+int	 fprintf  (FILE *, const char *, ...)  ;
+int	 fputc  (int, FILE *)  ;
+int	 fputs  (const char *, FILE *)  ;
+size_t	 fread  (void *, size_t, size_t, FILE *)  ;
+FILE	*freopen  (const char *, const char *, FILE *)  ;
+int	 fscanf  (FILE *, const char *, ...)  ;
+int	 fseek  (FILE *, long, int)  ;
+int	 fsetpos  (FILE *, const fpos_t *)  ;
+long	 ftell  (FILE *)  ;
+size_t	 fwrite  (const void *, size_t, size_t, FILE *)  ;
+int	 getc  (FILE *)  ;
+int	 getchar  (void)  ;
+char	*gets  (char *)  ;
+
+extern int sys_nerr;			 
+extern const  char * const  sys_errlist[];
+
+void	 perror  (const char *)  ;
+int	 printf  (const char *, ...)  ;
+int	 putc  (int, FILE *)  ;
+int	 putchar  (int)  ;
+int	 puts  (const char *)  ;
+int	 remove  (const char *)  ;
+int	 rename   (const char *, const char *)  ;
+void	 rewind  (FILE *)  ;
+int	 scanf  (const char *, ...)  ;
+void	 setbuf  (FILE *, char *)  ;
+int	 setvbuf  (FILE *, char *, int, size_t)  ;
+int	 sprintf  (char *, const char *, ...)  ;
+int	 sscanf  (const char *, const char *, ...)  ;
+FILE	*tmpfile  (void)  ;
+char	*tmpnam  (char *)  ;
+int	 ungetc  (int, FILE *)  ;
+int	 vfprintf  (FILE *, const char *, char * )  ;
+int	 vprintf  (const char *, char * )  ;
+int	 vsprintf  (char *, const char *, char * )  ;
+} 
+
+ 
+
+
+
+
+
+
+extern "C" { 
+char	*ctermid  (char *)  ;
+FILE	*fdopen  (int, const char *)  ;
+int	 fileno  (FILE *)  ;
+} 
+
+
+ 
+
+
+
+extern "C" { 
+char	*fgetln  (FILE *, size_t *)  ;
+int	 fpurge  (FILE *)  ;
+int	 fseeko  (FILE *, fpos_t, int)  ;
+fpos_t	ftello  (FILE *)  ;
+int	 getw  (FILE *)  ;
+int	 pclose  (FILE *)  ;
+FILE	*popen  (const char *, const char *)  ;
+int	 putw  (int, FILE *)  ;
+void	 setbuffer  (FILE *, char *, int)  ;
+int	 setlinebuf  (FILE *)  ;
+char	*tempnam  (const char *, const char *)  ;
+int	 snprintf  (char *, size_t, const char *, ...)  ;
+int	 vsnprintf  (char *, size_t, const char *, char * )  ;
+int	 vscanf  (const char *, char * )  ;
+int	 vsscanf  (const char *, const char *, char * )  ;
+FILE	*zopen  (const char *, const char *, int)  ;
+} 
+
+ 
+
+
+
+
+
+
+ 
+
+
+extern "C" { 
+FILE	*funopen  (const void *,
+		int (*)(void *, char *, int),
+		int (*)(void *, const char *, int),
+		fpos_t (*)(void *, fpos_t, int),
+		int (*)(void *))  ;
+} 
+
+
+
+
+ 
+
+
+extern "C" { 
+int	__srget  (FILE *)  ;
+int	__svfscanf  (FILE *, const char *, char * )  ;
+int	__swbuf  (int, FILE *)  ;
+} 
+
+ 
+
+
+
+
+
+static inline  int __sputc(int _c, FILE *_p) {
+	if (--_p->_w >= 0 || (_p->_w >= _p->_lbfsize && (char)_c != '\n'))
+		return (*_p->_p++ = _c);
+	else
+		return (__swbuf(_c, _p));
+}
+# 379 "/usr/include/stdio.h" 3 4
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 29 "/usr/include/libc.h" 2 3 4
+
+# 1 "/usr/include/standards.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 30 "/usr/include/libc.h" 2 3 4
+
+# 1 "/usr/include/unistd.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+# 1 "/usr/include/sys/unistd.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+				 
+
+				 
+
+				 
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+ 
+
+
+
+
+
+ 
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+# 72 "/usr/include/unistd.h" 2 3 4
+
+
+
+
+
+
+
+
+
+
+
+
+extern "C" { 
+  void
+	 _exit  (int)  ;
+int	 access  (const char *, int)  ;
+unsigned int	 alarm  (unsigned int)  ;
+int	 chdir  (const char *)  ;
+int	 chown  (const char *, uid_t, gid_t)  ;
+int	 close  (int)  ;
+size_t	 confstr  (int, char *, size_t)  ;
+int	 dup  (int)  ;
+int	 dup2  (int, int)  ;
+int	 execl  (const char *, const char *, ...)  ;
+int	 execle  (const char *, const char *, ...)  ;
+int	 execlp  (const char *, const char *, ...)  ;
+int	 execv  (const char *, char * const *)  ;
+int	 execve  (const char *, char * const *, char * const *)  ;
+int	 execvp  (const char *, char * const *)  ;
+pid_t	 fork  (void)  ;
+long	 fpathconf  (int, int)  ;
+char	*getcwd  (char *, size_t)  ;
+gid_t	 getegid  (void)  ;
+uid_t	 geteuid  (void)  ;
+gid_t	 getgid  (void)  ;
+int	 getgroups  (int, gid_t [])  ;
+char	*getlogin  (void)  ;
+pid_t	 getpgrp  (void)  ;
+pid_t	 getpid  (void)  ;
+pid_t	 getppid  (void)  ;
+uid_t	 getuid  (void)  ;
+int	 isatty  (int)  ;
+int	 link  (const char *, const char *)  ;
+off_t	 lseek  (int, off_t, int)  ;
+long	 pathconf  (const char *, int)  ;
+int	 pause  (void)  ;
+int	 pipe  (int *)  ;
+ssize_t	 read  (int, void *, size_t)  ;
+int	 rmdir  (const char *)  ;
+int	 setgid  (gid_t)  ;
+int	 setpgid  (pid_t, pid_t)  ;
+pid_t	 setsid  (void)  ;
+int	 setuid  (uid_t)  ;
+unsigned int	 sleep  (unsigned int)  ;
+long	 sysconf  (int)  ;
+pid_t	 tcgetpgrp  (int)  ;
+int	 tcsetpgrp  (int, pid_t)  ;
+char	*ttyname  (int)  ;
+int	 unlink  (const char *)  ;
+ssize_t	 write  (int, const void *, size_t)  ;
+
+extern char *optarg;			 
+extern int optind, opterr, optopt, optreset;
+int	 getopt  (int, char * const [], const char *)  ;
+
+
+
+struct timeval;				 
+
+int	 acct  (const char *)  ;
+int	 async_daemon  (void)  ;
+char	*brk  (const char *)  ;
+int	 chroot  (const char *)  ;
+char	*crypt  (const char *, const char *)  ;
+int	 des_cipher  (const char *, char *, long, int)  ;
+int	 des_setkey  (const char *key)  ;
+int	 encrypt  (char *, int)  ;
+void	 endusershell  (void)  ;
+int	 exect  (const char *, char * const *, char * const *)  ;
+int	 fchdir  (int)  ;
+int	 fchown  (int, int, int)  ;
+int	 fsync  (int)  ;
+int	 ftruncate  (int, off_t)  ;
+int	 getdtablesize  (void)  ;
+int	 getgrouplist  (const char *, int, int *, int *)  ;
+long	 gethostid  (void)  ;
+int	 gethostname  (char *, int)  ;
+mode_t	 getmode  (const void *, mode_t)  ;
+  int
+	 getpagesize  (void)  ;
+char	*getpass  (const char *)  ;
+char	*getusershell  (void)  ;
+char	*getwd  (char *)  ;			 
+int	 initgroups  (const char *, int)  ;
+int	 iruserok  (unsigned long, int, const char *, const char *)  ;
+int	 mknod  (const char *, mode_t, dev_t)  ;
+int	 mkstemp  (char *)  ;
+char	*mktemp  (char *)  ;
+int	 nfssvc  (int, void *)  ;
+int	 nice  (int)  ;
+
+
+
+
+# 1 "/usr/include/signal.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/usr/include/sys/signal.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/usr/include/machine/signal.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/usr/include/ppc/signal.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef int sig_atomic_t; 
+
+ 
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+typedef enum {
+	REGS_SAVED_NONE,		 
+	REGS_SAVED_CALLER,		 
+
+
+	REGS_SAVED_ALL			 
+} regs_saved_t;
+
+
+ 
+
+
+
+
+
+
+struct sigcontext {
+    int		sc_onstack;      
+    int		sc_mask;         
+	int		sc_ir;			 
+    int		sc_psw;          
+    int		sc_sp;      	 
+	void	*sc_regs;		 
+};
+
+
+
+# 27 "/usr/include/machine/signal.h" 2 3 4
+
+
+
+
+
+
+
+
+
+# 70 "/usr/include/sys/signal.h" 2 3 4
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef unsigned int sigset_t;
+
+ 
+
+
+struct	sigaction {
+
+	void	(*sa_handler)(int);	 
+
+
+
+	sigset_t sa_mask;		 
+	int	sa_flags;		 
+};
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+typedef	void (*sig_t)  (int)  ;	 
+
+ 
+
+
+struct	sigaltstack {
+	char	*ss_sp;		 
+	int	ss_size;		 
+	int	ss_flags;		 
+};
+
+
+
+ 
+
+
+
+struct	sigvec {
+	void	(*sv_handler)();	 
+	int	sv_mask;		 
+	int	sv_flags;		 
+};
+
+
+
+
+
+ 
+
+
+struct	sigstack {
+	char	*ss_sp;			 
+	int	ss_onstack;		 
+};
+
+ 
+
+
+
+
+
+# 213 "/usr/include/sys/signal.h" 3 4
+
+
+
+
+
+
+
+ 
+
+
+
+extern "C" { 
+void	(*signal  (int, void (*)  (int)  )  )  (int)  ;
+} 
+
+# 62 "/usr/include/signal.h" 2 3 4
+
+
+
+extern const  char * const  sys_signame[32 ];
+extern const  char * const  sys_siglist[32 ];
+
+
+extern "C" { 
+int	raise  (int)  ;
+
+int	kill  (pid_t, int)  ;
+int	sigaction  (int, const struct sigaction *, struct sigaction *)  ;
+int	sigaddset  (sigset_t *, int)  ;
+int	sigdelset  (sigset_t *, int)  ;
+int	sigemptyset  (sigset_t *)  ;
+int	sigfillset  (sigset_t *)  ;
+int	sigismember  (const sigset_t *, int)  ;
+int	sigpending  (sigset_t *)  ;
+int	sigprocmask  (int, const sigset_t *, sigset_t *)  ;
+int	sigsuspend  (const sigset_t *)  ;
+
+int	killpg  (pid_t, int)  ;
+int	sigblock  (int)  ;
+int	siginterrupt  (int, int)  ;
+int	sigpause  (int)  ;
+int	sigreturn  (struct sigcontext *)  ;
+int	sigsetmask  (int)  ;
+int	sigvec  (int, struct sigvec *, struct sigvec *)  ;
+void	psignal  (unsigned int, const char *)  ;
+
+
+} 
+
+ 
+
+
+
+
+
+
+
+# 176 "/usr/include/unistd.h" 2 3 4
+
+
+int	 profil  (char *, int, int, int)  ;
+int	 rcmd  (char **, int, const char *,
+		const char *, const char *, int *)  ;
+char	*re_comp  (const char *)  ;
+int	 re_exec  (const char *)  ;
+int	 readlink  (const char *, char *, int)  ;
+int	 reboot  (int)  ;
+int	 revoke  (const char *)  ;
+int	 rresvport  (int *)  ;
+int	 ruserok  (const char *, int, const char *, const char *)  ;
+char	*sbrk  (int)  ;
+int	 select  (int, fd_set *, fd_set *, fd_set *, struct timeval *)  ;
+int	 setegid  (gid_t)  ;
+int	 seteuid  (uid_t)  ;
+int	 setgroups  (int, const gid_t *)  ;
+void	 sethostid  (long)  ;
+int	 sethostname  (const char *, int)  ;
+int	 setkey  (const char *)  ;
+int	 setlogin  (const char *)  ;
+void	*setmode  (const char *)  ;
+int	 setpgrp  (pid_t pid, pid_t pgrp)  ;	 
+int	 setregid  (gid_t, gid_t)  ;
+int	 setreuid  (uid_t, uid_t)  ;
+int	 setrgid  (gid_t)  ;
+int	 setruid  (uid_t)  ;
+void	 setusershell  (void)  ;
+int	 swapon  (const char *)  ;
+int	 symlink  (const char *, const char *)  ;
+void	 sync  (void)  ;
+int	 syscall  (int, ...)  ;
+int	 truncate  (const char *, off_t)  ;
+int	 ttyslot  (void)  ;
+unsigned int	 ualarm  (unsigned int, unsigned int)  ;
+int	 unwhiteout  (const char *)  ;
+void	 usleep  (unsigned int)  ;
+void	*valloc  (size_t)  ;			 
+pid_t	 vfork  (void)  ;
+
+extern char *suboptarg;			 
+int	 getsubopt  (char **, char * const *, char **)  ;
+
+ 
+int	getattrlist  (const char*,void*,void*,size_t,unsigned long)  ;
+int	setattrlist  (const char*,void*,void*,size_t,unsigned long)  ;
+int exchangedata  (const char*,const char*,unsigned long)  ;
+int	checkuseraccess  (const char*,uid_t,gid_t*,int,int,unsigned long)  ;
+int	getdirentriesattr  (int,void*,void*,size_t,unsigned long*,unsigned long*,unsigned long*,unsigned long)  ;
+int	searchfs  (const char*,void*,void*,unsigned long,unsigned long,void*)  ;
+
+int fsctl  (const char *,unsigned long,void*,unsigned long)  ;		
+
+
+
+} 
+
+
+# 31 "/usr/include/libc.h" 2 3 4
+
+
+
+
+
+
+# 1 "/usr/include/string.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+extern "C" { 
+void	*memchr  (const void *, int, size_t)  ;
+int	 memcmp  (const void *, const void *, size_t)  ;
+void	*memcpy  (void *, const void *, size_t)  ;
+void	*memmove  (void *, const void *, size_t)  ;
+void	*memset  (void *, int, size_t)  ;
+char	*strcat  (char *, const char *)  ;
+char	*strchr  (const char *, int)  ;
+int	 strcmp  (const char *, const char *)  ;
+int	 strcoll  (const char *, const char *)  ;
+char	*strcpy  (char *, const char *)  ;
+size_t	 strcspn  (const char *, const char *)  ;
+char	*strerror  (int)  ;
+size_t	 strlen  (const char *)  ;
+char	*strncat  (char *, const char *, size_t)  ;
+int	 strncmp  (const char *, const char *, size_t)  ;
+char	*strncpy  (char *, const char *, size_t)  ;
+char	*strpbrk  (const char *, const char *)  ;
+char	*strrchr  (const char *, int)  ;
+size_t	 strspn  (const char *, const char *)  ;
+char	*strstr  (const char *, const char *)  ;
+char	*strtok  (char *, const char *)  ;
+size_t	 strxfrm  (char *, const char *, size_t)  ;
+
+ 
+
+int	 bcmp  (const void *, const void *, size_t)  ;
+void	 bcopy  (const void *, void *, size_t)  ;
+void	 bzero  (void *, size_t)  ;
+int	 ffs  (int)  ;
+char	*index  (const char *, int)  ;
+void	*memccpy  (void *, const void *, int, size_t)  ;
+char	*rindex  (const char *, int)  ;
+int	 strcasecmp  (const char *, const char *)  ;
+char	*strdup  (const char *)  ;
+void	 strmode  (int, char *)  ;
+int	 strncasecmp  (const char *, const char *, size_t)  ;
+char	*strsep  (char **, const char *)  ;
+void	 swab  (const void *, void *, size_t)  ;
+
+} 
+
+
+# 37 "/usr/include/libc.h" 2 3 4
+
+# 1 "/usr/include/stdlib.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef	__wchar_t 	rune_t;
+
+typedef	__wchar_t 	wchar_t;
+
+
+typedef struct {
+	int quot;		 
+	int rem;		 
+} div_t;
+
+typedef struct {
+	long quot;		 
+	long rem;		 
+} ldiv_t;
+
+
+
+
+
+
+
+
+
+
+extern int __mb_cur_max;
+
+
+
+
+extern "C" { 
+  void
+	 abort  (void)  ;
+  int
+	 abs  (int)  ;
+int	 atexit  (void (*)(void))  ;
+double	 atof  (const char *)  ;
+int	 atoi  (const char *)  ;
+long	 atol  (const char *)  ;
+void	*bsearch  (const void *, const void *, size_t,
+	    size_t, int (*)(const void *, const void *))  ;
+void	*calloc  (size_t, size_t)  ;
+  div_t
+	 div  (int, int)  ;
+  void
+	 exit  (int)  ;
+void	 free  (void *)  ;
+char	*getenv  (const char *)  ;
+  long
+	 labs  (long)  ;
+  ldiv_t
+	 ldiv  (long, long)  ;
+void	*malloc  (size_t)  ;
+void	 qsort  (void *, size_t, size_t,
+	    int (*)(const void *, const void *))  ;
+int	 rand  (void)  ;
+void	*realloc  (void *, size_t)  ;
+void	 srand  (unsigned)  ;
+double	 strtod  (const char *, char **)  ;
+long	 strtol  (const char *, char **, int)  ;
+unsigned long
+	 strtoul  (const char *, char **, int)  ;
+int	 system  (const char *)  ;
+
+ 
+int	 mblen  (const char *, size_t)  ;
+size_t	 mbstowcs  (wchar_t *, const char *, size_t)  ;
+int	 wctomb  (char *, wchar_t)  ;
+int	 mbtowc  (wchar_t *, const char *, size_t)  ;
+size_t	 wcstombs  (char *, const wchar_t *, size_t)  ;
+
+
+int	 putenv  (const char *)  ;
+int	 setenv  (const char *, const char *, int)  ;
+
+
+
+void	*alloca  (size_t)  ;		 
+					 
+char	*getbsize  (int *, long *)  ;
+char	*cgetcap  (char *, char *, int)  ;
+int	 cgetclose  (void)  ;
+int	 cgetent  (char **, char **, char *)  ;
+int	 cgetfirst  (char **, char **)  ;
+int	 cgetmatch  (char *, char *)  ;
+int	 cgetnext  (char **, char **)  ;
+int	 cgetnum  (char *, char *, long *)  ;
+int	 cgetset  (char *)  ;
+int	 cgetstr  (char *, char *, char **)  ;
+int	 cgetustr  (char *, char *, char **)  ;
+
+int	 daemon  (int, int)  ;
+char	*devname  (int, int)  ;
+int	 getloadavg  (double [], int)  ;
+
+char	*group_from_gid  (unsigned long, int)  ;
+int	 heapsort  (void *, size_t, size_t,
+	    int (*)(const void *, const void *))  ;
+char	*initstate  (unsigned long, char *, long)  ;
+int	 mergesort  (void *, size_t, size_t,
+	    int (*)(const void *, const void *))  ;
+int	 radixsort  (const unsigned char **, int, const unsigned char *,
+	    unsigned)  ;
+int	 sradixsort  (const unsigned char **, int, const unsigned char *,
+	    unsigned)  ;
+long	 random  (void)  ;
+char	*realpath  (const char *, char resolved_path[])  ;
+char	*setstate  (char *)  ;
+void	 srandom  (unsigned long)  ;
+char	*user_from_uid  (unsigned long, int)  ;
+
+long long
+	 strtoq  (const char *, char **, int)  ;
+unsigned long long
+	 strtouq  (const char *, char **, int)  ;
+
+void	 unsetenv  (const char *)  ;
+
+} 
+
+
+# 38 "/usr/include/libc.h" 2 3 4
+
+# 1 "/usr/include/time.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+struct tm {
+	int	tm_sec;		 
+	int	tm_min;		 
+	int	tm_hour;	 
+	int	tm_mday;	 
+	int	tm_mon;		 
+	int	tm_year;	 
+	int	tm_wday;	 
+	int	tm_yday;	 
+	int	tm_isdst;	 
+	long	tm_gmtoff;	 
+	char	*tm_zone;	 
+};
+
+# 1 "/usr/include/gcc/darwin/2.95.2/g++/../machine/limits.h" 1 3
+
+
+# 1 "/usr/include/ppc/limits.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 3 "/usr/include/gcc/darwin/2.95.2/g++/../machine/limits.h" 2 3
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+ 
+
+
+
+ 
+
+
+
+
+ 
+
+
+
+
+
+ 
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+ 
+
+
+
+
+ 
+
+
+
+ 
+
+
+
+
+
+
+
+
+ 
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+# 100 "/usr/include/time.h" 2 3 4
+
+
+
+
+
+
+extern "C" { 
+char *asctime  (const struct tm *)  ;
+clock_t clock  (void)  ;
+char *ctime  (const time_t *)  ;
+double difftime  (time_t, time_t)  ;
+struct tm *gmtime  (const time_t *)  ;
+struct tm *localtime  (const time_t *)  ;
+time_t mktime  (struct tm *)  ;
+size_t strftime  (char *, size_t, const char *, const struct tm *)  ;
+time_t time  (time_t *)  ;
+
+
+void tzset  (void)  ;
+
+
+
+char *timezone  (int, int)  ;
+void tzsetwall  (void)  ;
+
+} 
+
+
+# 39 "/usr/include/libc.h" 2 3 4
+
+# 1 "/usr/include/gcc/darwin/2.95.2/g++/../stdarg.h" 1 3
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/usr/include/gcc/darwin/2.95.2/g++/../va-ppc.h" 1 3
+ 
+
+
+ 
+ 
+
+
+
+typedef char *__gnuc_va_list;
+
+
+ 
+
+
+
+
+
+ 
+
+
+
+
+# 43 "/usr/include/gcc/darwin/2.95.2/g++/../va-ppc.h" 3
+
+
+
+void va_end (__gnuc_va_list);		 
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+# 352 "/usr/include/gcc/darwin/2.95.2/g++/../va-ppc.h" 3
+
+# 42 "/usr/include/gcc/darwin/2.95.2/g++/../stdarg.h" 2 3
+
+# 131 "/usr/include/gcc/darwin/2.95.2/g++/../stdarg.h" 3
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 175 "/usr/include/gcc/darwin/2.95.2/g++/../stdarg.h" 3
+
+
+ 
+
+
+
+
+ 
+
+ 
+
+ 
+
+typedef __gnuc_va_list va_list;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 40 "/usr/include/libc.h" 2 3 4
+
+
+
+# 1 "/usr/include/sys/mount.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/usr/include/sys/ucred.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/usr/include/sys/param.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+# 1 "/usr/include/sys/syslimits.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 88 "/usr/include/sys/param.h" 2 3 4
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+# 1 "/usr/include/machine/param.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+# 1 "/usr/include/ppc/param.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+					 
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+		 
+
+
+
+ 
+
+
+
+
+ 
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+# 30 "/usr/include/machine/param.h" 2 3 4
+
+
+
+
+
+
+
+
+
+# 102 "/usr/include/sys/param.h" 2 3 4
+
+# 1 "/usr/include/gcc/darwin/2.95.2/g++/../machine/limits.h" 1 3
+# 10 "/usr/include/gcc/darwin/2.95.2/g++/../machine/limits.h" 3
+
+# 108 "/usr/include/gcc/darwin/2.95.2/g++/../machine/limits.h" 3
+
+# 103 "/usr/include/sys/param.h" 2 3 4
+
+
+ 
+
+
+
+
+
+
+
+
+
+ 
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+				 
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+ 
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 61 "/usr/include/sys/ucred.h" 2 3 4
+
+
+ 
+
+
+struct ucred {
+	u_long	cr_ref;			 
+	uid_t	cr_uid;			 
+	short	cr_ngroups;		 
+	gid_t	cr_groups[16  ];	 
+};
+
+
+
+
+# 88 "/usr/include/sys/ucred.h" 3 4
+
+
+
+# 62 "/usr/include/sys/mount.h" 2 3 4
+
+
+# 1 "/usr/include/sys/queue.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+ 
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 184 "/usr/include/sys/queue.h" 3 4
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 260 "/usr/include/sys/queue.h" 3 4
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 378 "/usr/include/sys/queue.h" 3 4
+
+
+
+
+
+
+
+
+
+# 395 "/usr/include/sys/queue.h" 3 4
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 453 "/usr/include/sys/queue.h" 3 4
+
+
+# 463 "/usr/include/sys/queue.h" 3 4
+
+
+# 473 "/usr/include/sys/queue.h" 3 4
+
+
+# 483 "/usr/include/sys/queue.h" 3 4
+
+
+
+
+
+
+
+
+# 502 "/usr/include/sys/queue.h" 3 4
+
+# 548 "/usr/include/sys/queue.h" 3 4
+
+
+
+# 64 "/usr/include/sys/mount.h" 2 3 4
+
+# 1 "/usr/include/sys/lock.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 74 "/usr/include/sys/lock.h" 3 4
+
+
+
+
+
+# 1 "/usr/include/mach/boolean.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+ 
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+# 1 "/usr/include/mach/machine/boolean.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/usr/include/mach/ppc/boolean.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+ 
+
+
+
+
+
+
+
+
+typedef int		boolean_t;
+
+
+# 27 "/usr/include/mach/machine/boolean.h" 2 3 4
+
+
+
+
+
+
+
+
+
+# 127 "/usr/include/mach/boolean.h" 2 3 4
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 79 "/usr/include/sys/lock.h" 2 3 4
+
+
+
+struct slock{
+	volatile unsigned int lock_data[10];
+};
+
+
+
+
+
+typedef struct slock	simple_lock_data_t;
+typedef struct slock	*simple_lock_t;
+
+
+
+
+
+
+ 
+
+
+
+
+struct lock__bsd__ {
+	simple_lock_data_t
+		lk_interlock;		 
+	u_int	lk_flags;		 
+	int	lk_sharecount;		 
+	int	lk_waitcount;		 
+	short	lk_exclusivecount;	 
+	short	lk_prio;		 
+	char	*lk_wmesg;		 
+	int	lk_timo;		 
+	pid_t	lk_lockholder;		 
+	void	*lk_lockthread;		 
+};
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+struct proc;
+
+void	lockinit  (struct lock__bsd__ *, int prio, char *wmesg, int timo,
+			int flags)  ;
+int	lockmgr  (struct lock__bsd__ *, u_int flags,
+			simple_lock_t, struct proc *p)  ;
+int	lockstatus  (struct lock__bsd__ *)  ;
+
+
+# 65 "/usr/include/sys/mount.h" 2 3 4
+
+# 1 "/usr/include/net/radix.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+struct radix_node {
+	struct	radix_mask *rn_mklist;	 
+	struct	radix_node *rn_p;	 
+	short	rn_b;			 
+	char	rn_bmask;		 
+	u_char	rn_flags;		 
+
+
+
+	union {
+		struct {			 
+			caddr_t	rn_Key;		 
+			caddr_t	rn_Mask;	 
+			struct	radix_node *rn_Dupedkey;
+		} rn_leaf;
+		struct {			 
+			int	rn_Off;		 
+			struct	radix_node *rn_L; 
+			struct	radix_node *rn_R; 
+		} rn_node;
+	}		rn_u;
+
+
+
+
+
+};
+
+
+
+
+
+
+
+
+ 
+
+
+
+struct radix_mask {
+	short	rm_b;			 
+	char	rm_unused;		 
+	u_char	rm_flags;		 
+	struct	radix_mask *rm_mklist;	 
+	union	{
+		caddr_t	rmu_mask;		 
+		struct	radix_node *rmu_leaf;	 
+	}	rm_rmu;
+	int	rm_refs;		 
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef int walktree_f_t  (struct radix_node *, void *)  ;
+
+struct radix_node_head {
+	struct	radix_node *rnh_treetop;
+	int	rnh_addrsize;		 
+	int	rnh_pktsize;		 
+	struct	radix_node *(*rnh_addaddr)	 
+		 (void *v, void *mask,
+		     struct radix_node_head *head, struct radix_node nodes[])  ;
+	struct	radix_node *(*rnh_addpkt)	 
+		 (void *v, void *mask,
+		     struct radix_node_head *head, struct radix_node nodes[])  ;
+	struct	radix_node *(*rnh_deladdr)	 
+		 (void *v, void *mask, struct radix_node_head *head)  ;
+	struct	radix_node *(*rnh_delpkt)	 
+		 (void *v, void *mask, struct radix_node_head *head)  ;
+	struct	radix_node *(*rnh_matchaddr)	 
+		 (void *v, struct radix_node_head *head)  ;
+	struct	radix_node *(*rnh_lookup)	 
+		 (void *v, void *mask, struct radix_node_head *head)  ;
+	struct	radix_node *(*rnh_matchpkt)	 
+		 (void *v, struct radix_node_head *head)  ;
+	int	(*rnh_walktree)			 
+		 (struct radix_node_head *head, walktree_f_t *f, void *w)  ;
+	int	(*rnh_walktree_from)		 
+		 (struct radix_node_head *head, void *a, void *m,
+		     walktree_f_t *f, void *w)  ;
+	void	(*rnh_close)	 
+		 (struct radix_node *rn, struct radix_node_head *head)  ;
+	struct	radix_node rnh_nodes[3];	 
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+void	 rn_init  (void)  ;
+int	 rn_inithead  (void **, int)  ;
+int	 rn_refines  (void *, void *)  ;
+struct radix_node
+	 *rn_addmask  (void *, int, int)  ,
+	 *rn_addroute  (void *, void *, struct radix_node_head *,
+			struct radix_node [2])  ,
+	 *rn_delete  (void *, void *, struct radix_node_head *)  ,
+	 *rn_lookup  (void *v_arg, void *m_arg,
+		        struct radix_node_head *head)  ,
+	 *rn_match  (void *, struct radix_node_head *)  ;
+
+
+
+# 66 "/usr/include/sys/mount.h" 2 3 4
+
+# 1 "/usr/include/sys/socket.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+ 
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+					 
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+struct	linger {
+	int	l_onoff;		 
+	int	l_linger;		 
+};
+
+ 
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+					 
+					 
+					 
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+struct sockaddr {
+	u_char	sa_len;			 
+	u_char	sa_family;		 
+	char	sa_data[14];		 
+};
+
+
+ 
+
+
+
+struct sockproto {
+	u_short	sp_family;		 
+	u_short	sp_protocol;		 
+};
+
+
+ 
+
+
+
+
+
+
+
+
+struct sockaddr_storage {
+	u_char ss_len;		 
+	u_char ss_family;	 
+	char _ss_pad1[((sizeof(int64_t))  - sizeof(u_char) * 2) ];
+	int64_t _ss_align;	 
+	char _ss_pad2[(128  - sizeof(u_char) * 2 - ((sizeof(int64_t))  - sizeof(u_char) * 2)  - (sizeof(int64_t)) ) ];
+};
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+# 295 "/usr/include/sys/socket.h" 3 4
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+ 
+
+
+
+struct msghdr {
+	caddr_t	msg_name;		 
+	u_int	msg_namelen;		 
+	struct	iovec *msg_iov;		 
+	u_int	msg_iovlen;		 
+	caddr_t	msg_control;		 
+	u_int	msg_controllen;		 
+	int	msg_flags;		 
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+struct cmsghdr {
+	u_int	cmsg_len;		 
+	int	cmsg_level;		 
+	int	cmsg_type;		 
+ 
+};
+
+ 
+
+
+ 
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+ 
+
+
+struct osockaddr {
+	u_short	sa_family;		 
+	char	sa_data[14];		 
+};
+
+ 
+
+
+struct omsghdr {
+	caddr_t	msg_name;		 
+	int	msg_namelen;		 
+	struct	iovec *msg_iov;		 
+	int	msg_iovlen;		 
+	caddr_t	msg_accrights;		 
+	int	msg_accrightslen;
+};
+
+ 
+
+
+
+
+
+
+# 427 "/usr/include/sys/socket.h" 3 4
+
+
+
+
+
+
+extern "C" { 
+int	accept  (int, struct sockaddr *, int *)  ;
+int	bind  (int, const struct sockaddr *, int)  ;
+int	connect  (int, const struct sockaddr *, int)  ;
+int	getpeername  (int, struct sockaddr *, int *)  ;
+int	getsockname  (int, struct sockaddr *, int *)  ;
+int	getsockopt  (int, int, int, void *, int *)  ;
+int	listen  (int, int)  ;
+ssize_t	recv  (int, void *, size_t, int)  ;
+ssize_t	recvfrom  (int, void *, size_t, int, struct sockaddr *, int *)  ;
+ssize_t	recvmsg  (int, struct msghdr *, int)  ;
+ssize_t	send  (int, const void *, size_t, int)  ;
+ssize_t	sendto  (int, const void *,
+	    size_t, int, const struct sockaddr *, int)  ;
+ssize_t	sendmsg  (int, const struct msghdr *, int)  ;
+
+
+
+int	setsockopt  (int, int, int, const void *, int)  ;
+int	shutdown  (int, int)  ;
+int	socket  (int, int, int)  ;
+int	socketpair  (int, int, int, int *)  ;
+} 
+
+
+
+# 67 "/usr/include/sys/mount.h" 2 3 4
+
+
+typedef struct fsid { int32_t val[2]; } fsid_t;	 
+
+ 
+
+
+
+
+
+struct fid {
+	u_short		fid_len;		 
+	u_short		fid_reserved;		 
+	char		fid_data[16 ];	 
+};
+
+ 
+
+
+
+
+
+
+struct statfs {
+	short	f_otype;		 
+	short	f_oflags;		 
+	long	f_bsize;		 
+	long	f_iosize;		 
+	long	f_blocks;		 
+	long	f_bfree;		 
+	long	f_bavail;		 
+	long	f_files;		 
+	long	f_ffree;		 
+	fsid_t	f_fsid;			 
+	uid_t	f_owner;		 
+	short	f_reserved1;	 
+	short	f_type;			 
+    long	f_flags;		 
+	long    f_reserved2[2];	 
+	char	f_fstypename[15 ];  
+	char	f_mntonname[90 ];	 
+	char	f_mntfromname[90 ]; 
+
+
+
+
+	char	f_reserved3;	 
+	long	f_reserved4[4];	 
+
+};
+
+ 
+
+
+
+
+struct  vnodelst  {	struct   vnode  *lh_first;	} ;
+
+struct mount {
+	struct {	struct  mount  *cqe_next;	struct  mount  *cqe_prev;	}  mnt_list;		 
+	struct vfsops	*mnt_op;		 
+	struct vfsconf	*mnt_vfc;		 
+	struct vnode	*mnt_vnodecovered;	 
+	struct vnodelst	mnt_vnodelist;		 
+	struct lock__bsd__ mnt_lock;		 
+	int		mnt_flag;		 
+	int		mnt_kern_flag;		 
+	int		mnt_maxsymlinklen;	 
+	struct statfs	mnt_stat;		 
+	qaddr_t		mnt_data;		 
+};
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+ 
+
+
+struct fhandle {
+	fsid_t	fh_fsid;	 
+	struct	fid fh_fid;	 
+};
+typedef struct fhandle	fhandle_t;
+
+ 
+
+
+struct export_args {
+	int	ex_flags;		 
+	uid_t	ex_root;		 
+	struct	ucred ex_anon;		 
+	struct	sockaddr *ex_addr;	 
+	int	ex_addrlen;		 
+	struct	sockaddr *ex_mask;	 
+	int	ex_masklen;		 
+};
+
+ 
+
+
+
+
+struct vfsconf {
+	struct	vfsops *vfc_vfsops;	 
+	char	vfc_name[15 ];	 
+	int	vfc_typenum;		 
+	int	vfc_refcount;		 
+	int	vfc_flags;		 
+	int	(*vfc_mountroot)(void);	 
+	struct	vfsconf *vfc_next;	 
+};
+
+# 361 "/usr/include/sys/mount.h" 3 4
+
+
+
+
+extern "C" { 
+int	fstatfs  (int, struct statfs *)  ;
+int	getfh  (const char *, fhandle_t *)  ;
+int	getfsstat  (struct statfs *, long, int)  ;
+int	getmntinfo  (struct statfs **, int)  ;
+int	mount  (const char *, const char *, int, void *)  ;
+int	statfs  (const char *, struct statfs *)  ;
+int	unmount  (const char *, int)  ;
+} 
+
+
+
+# 43 "/usr/include/libc.h" 2 3 4
+
+
+# 1 "/usr/include/sys/wait.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+ 
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+ 
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+union wait {
+	int	w_status;		 
+	 
+
+
+	struct {
+
+
+
+
+
+
+
+		unsigned int	w_Filler:16,	 
+				w_Retcode:8,	 
+				w_Coredump:1,	 
+				w_Termsig:7;	 
+
+	} w_T;
+	 
+
+
+
+
+	struct {
+
+
+
+
+
+
+		unsigned int	w_Filler:16,	 
+				w_Stopsig:8,	 
+				w_Stopval:8;	 
+
+	} w_S;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+extern "C" { 
+struct rusage;	 
+
+pid_t	wait  (int *)  ;
+pid_t	waitpid  (pid_t, int *, int)  ;
+
+pid_t	wait3  (int *, int, struct rusage *)  ;
+pid_t	wait4  (pid_t, int *, int, struct rusage *)  ;
+
+} 
+
+
+# 45 "/usr/include/libc.h" 2 3 4
+
+# 1 "/usr/include/sys/time.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+struct timeval {
+	int32_t	tv_sec;		 
+	int32_t	tv_usec;	 
+};
+
+ 
+
+
+struct timespec {
+	time_t	tv_sec;		 
+	int32_t	tv_nsec;	 
+};
+
+
+
+
+
+
+
+
+
+
+struct timezone {
+	int	tz_minuteswest;	 
+	int	tz_dsttime;	 
+};
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+# 121 "/usr/include/sys/time.h" 3 4
+
+# 130 "/usr/include/sys/time.h" 3 4
+
+ 
+
+
+
+
+
+
+
+struct	itimerval {
+	struct	timeval it_interval;	 
+	struct	timeval it_value;	 
+};
+
+ 
+
+
+struct clockinfo {
+	int	hz;		 
+	int	tick;		 
+	int	tickadj;	 
+	int	stathz;		 
+	int	profhz;		 
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+extern "C" { 
+int	adjtime  (const struct timeval *, struct timeval *)  ;
+int	getitimer  (int, struct itimerval *)  ;
+int	gettimeofday  (struct timeval *, struct timezone *)  ;
+int	setitimer  (int, const struct itimerval *, struct itimerval *)  ;
+int	settimeofday  (const struct timeval *, const struct timezone *)  ;
+int	utimes  (const char *, const struct timeval *)  ;
+} 
+
+
+
+
+
+# 46 "/usr/include/libc.h" 2 3 4
+
+# 1 "/usr/include/sys/times.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+struct tms {
+	clock_t tms_utime;	 
+	clock_t tms_stime;	 
+	clock_t tms_cutime;	 
+	clock_t tms_cstime;	 
+};
+
+
+
+
+extern "C" { 
+clock_t	times  (struct tms *)  ;
+} 
+
+
+# 47 "/usr/include/libc.h" 2 3 4
+
+# 1 "/usr/include/sys/resource.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+struct	rusage {
+	struct timeval ru_utime;	 
+	struct timeval ru_stime;	 
+	long	ru_maxrss;		 
+
+	long	ru_ixrss;		 
+	long	ru_idrss;		 
+	long	ru_isrss;		 
+	long	ru_minflt;		 
+	long	ru_majflt;		 
+	long	ru_nswap;		 
+	long	ru_inblock;		 
+	long	ru_oublock;		 
+	long	ru_msgsnd;		 
+	long	ru_msgrcv;		 
+	long	ru_nsignals;		 
+	long	ru_nvcsw;		 
+	long	ru_nivcsw;		 
+
+};
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+struct orlimit {
+	int32_t	rlim_cur;		 
+	int32_t	rlim_max;		 
+};
+
+struct rlimit {
+	rlim_t	rlim_cur;		 
+	rlim_t	rlim_max;		 
+};
+
+ 
+struct loadavg {
+	fixpt_t	ldavg[3];
+	long	fscale;
+};
+
+
+
+
+
+
+
+extern "C" { 
+int	getpriority  (int, int)  ;
+int	getrlimit  (int, struct rlimit *)  ;
+int	getrusage  (int, struct rusage *)  ;
+int	setpriority  (int, int, int)  ;
+int	setrlimit  (int, const struct rlimit *)  ;
+} 
+
+
+
+# 48 "/usr/include/libc.h" 2 3 4
+
+
+
+
+# 1 "/usr/include/sys/stat.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+struct ostat {
+	u_int16_t st_dev;		 
+	ino_t	  st_ino;		 
+	mode_t	  st_mode;		 
+	nlink_t	  st_nlink;		 
+	u_int16_t st_uid;		 
+	u_int16_t st_gid;		 
+	u_int16_t st_rdev;		 
+	int32_t	  st_size;		 
+	struct	timespec st_atimespec;	 
+	struct	timespec st_mtimespec;	 
+	struct	timespec st_ctimespec;	 
+	int32_t	  st_blksize;		 
+	int32_t	  st_blocks;		 
+	u_int32_t st_flags;		 
+	u_int32_t st_gen;		 
+};
+
+
+struct stat {
+	dev_t	  st_dev;		 
+	ino_t	  st_ino;		 
+	mode_t	  st_mode;		 
+	nlink_t	  st_nlink;		 
+	uid_t	  st_uid;		 
+	gid_t	  st_gid;		 
+	dev_t	  st_rdev;		 
+
+	struct	timespec st_atimespec;	 
+	struct	timespec st_mtimespec;	 
+	struct	timespec st_ctimespec;	 
+
+
+
+
+
+
+
+
+	off_t	  st_size;		 
+	int64_t	  st_blocks;		 
+	u_int32_t st_blksize;		 
+	u_int32_t st_flags;		 
+	u_int32_t st_gen;		 
+	int32_t	  st_lspare;
+	int64_t	  st_qspare[2];
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+							 
+
+							 
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+extern "C" { 
+int	chmod  (const char *, mode_t)  ;
+int	fstat  (int, struct stat *)  ;
+int	mkdir  (const char *, mode_t)  ;
+int	mkfifo  (const char *, mode_t)  ;
+int	stat  (const char *, struct stat *)  ;
+mode_t	umask  (mode_t)  ;
+
+int	chflags  (const char *, u_long)  ;
+int	fchflags  (int, u_long)  ;
+int	fchmod  (int, mode_t)  ;
+int	lstat  (const char *, struct stat *)  ;
+
+} 
+
+
+# 52 "/usr/include/libc.h" 2 3 4
+
+# 1 "/usr/include/sys/file.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/usr/include/sys/fcntl.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+ 
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+# 131 "/usr/include/sys/fcntl.h" 3 4
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+	
+
+
+
+
+
+
+
+ 
+
+
+ 
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+ 
+
+
+					 	
+
+ 
+
+
+
+struct flock {
+	off_t	l_start;	 
+	off_t	l_len;		 
+	pid_t	l_pid;		 
+	short	l_type;		 
+	short	l_whence;	 
+};
+
+
+ 
+
+
+
+struct radvisory {
+       off_t   ra_offset;
+       int     ra_count;
+};
+
+
+
+ 
+
+
+
+
+
+
+ 
+
+typedef struct fstore {
+        u_int32_t fst_flags;	 
+	int 	fst_posmode;	 
+	off_t	fst_offset;	 
+	off_t	fst_length;	 
+	off_t   fst_bytesalloc;	 
+} fstore_t;
+
+ 
+
+typedef struct fbootstraptransfer {
+  off_t fbt_offset;              
+  size_t fbt_length;             
+  void *fbt_buffer;              
+} fbootstraptransfer_t;
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+struct log2phys {
+	u_int32_t	l2p_flags;		 
+	off_t		l2p_contigbytes;	 
+	off_t		l2p_devoffset;	 
+};
+
+
+
+
+
+
+
+
+
+extern "C" { 
+int	open  (const char *, int, ...)  ;
+int	creat  (const char *, mode_t)  ;
+int	fcntl  (int, int, ...)  ;
+
+int	flock  (int, int)  ;
+
+} 
+
+
+
+# 61 "/usr/include/sys/file.h" 2 3 4
+
+
+
+# 112 "/usr/include/sys/file.h" 3 4
+
+
+
+# 53 "/usr/include/libc.h" 2 3 4
+
+
+# 1 "/usr/include/sys/ioctl.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/usr/include/sys/ttycom.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/usr/include/sys/ioccom.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+				 
+
+				 
+
+				 
+
+				 
+
+				 
+
+
+
+
+
+
+
+ 
+
+
+
+# 66 "/usr/include/sys/ttycom.h" 2 3 4
+
+
+ 
+
+
+
+
+ 
+
+
+
+struct winsize {
+	unsigned short	ws_row;		 
+	unsigned short	ws_col;		 
+	unsigned short	ws_xpixel;	 
+	unsigned short	ws_ypixel;	 
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+						 
+
+
+						 
+
+						 
+
+
+
+
+
+
+						 
+
+
+
+
+
+
+						 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 66 "/usr/include/sys/ioctl.h" 2 3 4
+
+
+ 
+
+
+
+
+struct ttysize {
+	unsigned short	ts_lines;
+	unsigned short	ts_cols;
+	unsigned short	ts_xxx;
+	unsigned short	ts_yyy;
+};
+
+
+
+
+
+# 1 "/usr/include/sys/filio.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+# 84 "/usr/include/sys/ioctl.h" 2 3 4
+
+# 1 "/usr/include/sys/sockio.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+   
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+                             
+
+
+# 85 "/usr/include/sys/ioctl.h" 2 3 4
+
+
+
+
+
+
+extern "C" { 
+int	ioctl  (int, unsigned long, ...)  ;
+} 
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+# 55 "/usr/include/libc.h" 2 3 4
+
+# 1 "/usr/include/netinet/in.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+ 
+ 
+
+
+
+
+ 
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+ 
+
+
+struct in_addr {
+	u_int32_t s_addr;
+};
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+struct sockaddr_in {
+	u_char	sin_len;
+	u_char	sin_family;
+	u_short	sin_port;
+	struct	in_addr sin_addr;
+	char	sin_zero[8];
+};
+
+
+
+ 
+
+
+
+
+
+
+struct ip_opts {
+	struct	in_addr ip_dst;		 
+	char	ip_opts[40];		 
+};
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+ 
+
+
+struct ip_mreq {
+	struct	in_addr imr_multiaddr;	 
+	struct	in_addr imr_interface;	 
+};
+
+ 
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+# 456 "/usr/include/netinet/in.h" 3 4
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 499 "/usr/include/netinet/in.h" 3 4
+
+ 
+
+# 1 "/usr/include/netinet6/in6.h" 1 3 4
+ 
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+struct in6_addr {
+	union {
+		u_int8_t   __u6_addr8[16];
+		u_int16_t  __u6_addr16[8];
+		u_int32_t  __u6_addr32[4];
+	} __u6_addr;			 
+};
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+struct sockaddr_in6 {
+	u_int8_t	sin6_len;	 
+	u_int8_t	sin6_family;	 
+	u_int16_t	sin6_port;	 
+	u_int32_t	sin6_flowinfo;	 
+	struct in6_addr	sin6_addr;	 
+	u_int32_t	sin6_scope_id;	 
+};
+
+ 
+
+
+# 166 "/usr/include/netinet6/in6.h" 3 4
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+# 199 "/usr/include/netinet6/in6.h" 3 4
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+# 335 "/usr/include/netinet6/in6.h" 3 4
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+ 
+
+
+
+struct route_in6 {
+	struct	rtentry *ro_rt;
+	struct	sockaddr_in6 ro_dst;
+};
+
+
+ 
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+				    
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+ 
+
+
+struct ipv6_mreq {
+	struct in6_addr	ipv6mr_multiaddr;
+	u_int		ipv6mr_interface;
+};
+
+ 
+
+
+struct in6_pktinfo {
+	struct in6_addr ipi6_addr;	 
+	u_int ipi6_ifindex;		 
+};
+
+ 
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+# 530 "/usr/include/netinet6/in6.h" 3 4
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 611 "/usr/include/netinet6/in6.h" 3 4
+
+# 640 "/usr/include/netinet6/in6.h" 3 4
+
+
+
+# 666 "/usr/include/netinet6/in6.h" 3 4
+
+
+extern "C" { 
+struct cmsghdr;
+
+extern int inet6_option_space  (int)  ;
+extern int inet6_option_init  (void *, struct cmsghdr **, int)  ;
+extern int inet6_option_append  (struct cmsghdr *, const u_int8_t *,
+	int, int)  ;
+extern u_int8_t *inet6_option_alloc  (struct cmsghdr *, int, int, int)  ;
+extern int inet6_option_next  (const struct cmsghdr *, u_int8_t **)  ;
+extern int inet6_option_find  (const struct cmsghdr *, u_int8_t **, int)  ;
+
+extern size_t inet6_rthdr_space  (int, int)  ;
+extern struct cmsghdr *inet6_rthdr_init  (void *, int)  ;
+extern int inet6_rthdr_add  (struct cmsghdr *, const struct in6_addr *,
+		unsigned int)  ;
+extern int inet6_rthdr_lasthop  (struct cmsghdr *, unsigned int)  ;
+
+
+
+extern int inet6_rthdr_segments  (const struct cmsghdr *)  ;
+extern struct in6_addr *inet6_rthdr_getaddr  (struct cmsghdr *, int)  ;
+extern int inet6_rthdr_getflags  (const struct cmsghdr *, int)  ;
+
+extern int inet6_opt_init  (void *, size_t)  ;
+extern int inet6_opt_append  (void *, size_t, int, u_int8_t,
+				 size_t, u_int8_t, void **)  ;
+extern int inet6_opt_finish  (void *, size_t, int)  ;
+extern int inet6_opt_set_val  (void *, size_t, void *, int)  ;
+
+extern int inet6_opt_next  (void *, size_t, int, u_int8_t *,
+			       size_t *, void **)  ;
+extern int inet6_opt_find  (void *, size_t, int, u_int8_t,
+			  size_t *, void **)  ;
+extern int inet6_opt_get_val  (void *, size_t, void *, int)  ;
+extern size_t inet6_rth_space  (int, int)  ;
+extern void *inet6_rth_init  (void *, int, int, int)  ;
+extern int inet6_rth_add  (void *, const struct in6_addr *)  ;
+extern int inet6_rth_reverse  (const void *, void *)  ;
+extern int inet6_rth_segments  (const void *)  ;
+extern struct in6_addr *inet6_rth_getaddr  (const void *, int)  ;
+} 
+
+
+# 502 "/usr/include/netinet/in.h" 2 3 4
+
+
+
+# 514 "/usr/include/netinet/in.h" 3 4
+
+
+
+# 56 "/usr/include/libc.h" 2 3 4
+
+# 1 "/usr/include/arpa/inet.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+extern "C" { 
+unsigned long	 inet_addr  (const char *)  ;
+int		 inet_aton  (const char *, struct in_addr *)  ;
+unsigned long	 inet_lnaof  (struct in_addr)  ;
+struct in_addr	 inet_makeaddr  (u_long , u_long)  ;
+unsigned long	 inet_netof  (struct in_addr)  ;
+unsigned long	 inet_network  (const char *)  ;
+char		*inet_ntoa  (struct in_addr)  ;
+} 
+
+
+# 57 "/usr/include/libc.h" 2 3 4
+
+# 1 "/usr/include/mach/machine/vm_types.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/usr/include/mach/ppc/vm_types.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+typedef unsigned int	natural_t;
+
+ 
+
+
+
+
+
+
+typedef int		integer_t;
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+typedef	natural_t	vm_offset_t;
+
+ 
+
+
+
+
+typedef	natural_t		vm_size_t;
+typedef	unsigned long long	vm_double_size_t;
+
+ 
+
+
+typedef unsigned int	space_t;
+
+
+
+ 
+
+
+
+
+
+
+# 27 "/usr/include/mach/machine/vm_types.h" 2 3 4
+
+
+
+
+
+
+
+
+
+# 58 "/usr/include/libc.h" 2 3 4
+
+
+# 1 "/usr/include/mach/kern_return.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/usr/include/mach/machine/kern_return.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/usr/include/mach/ppc/kern_return.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+typedef	int		kern_return_t;
+
+
+# 27 "/usr/include/mach/machine/kern_return.h" 2 3 4
+
+
+
+
+
+
+
+
+
+# 64 "/usr/include/mach/kern_return.h" 2 3 4
+
+
+ 
+
+
+
+
+
+
+
+		 
+
+
+
+		 
+
+
+
+
+		 
+
+
+
+
+
+		 
+
+
+
+
+		 
+
+
+
+		 
+
+
+
+
+		 
+
+
+
+
+		 
+
+
+
+		 
+
+
+
+
+
+		 
+
+
+
+
+
+
+
+		 
+
+
+
+		 
+
+
+
+		 
+
+
+
+		 
+
+
+
+
+		 
+
+
+
+		 
+
+
+
+		 
+
+
+
+		 
+
+
+
+		 
+
+
+
+		 
+
+
+
+		 
+
+
+
+
+		 
+
+
+
+		 
+
+
+
+
+
+		 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+		 
+
+
+
+
+
+
+
+		 
+
+
+
+
+		 
+
+
+
+
+		 
+
+
+
+
+		 
+
+
+
+
+		 
+
+
+
+
+		 
+
+
+
+
+		 
+
+
+
+
+
+		 
+
+
+
+		 
+
+
+
+		 
+
+
+		
+
+		 
+
+
+		
+
+		 
+
+
+
+		 
+
+
+
+		 
+
+
+
+
+		 
+
+
+
+		 
+
+
+
+		 
+
+
+
+		 
+
+
+
+
+		 
+
+
+
+		 
+
+
+
+		 
+
+
+
+		 
+
+
+
+		 
+
+
+		 
+
+
+
+		 
+
+
+
+# 60 "/usr/include/libc.h" 2 3 4
+
+
+struct qelem {
+        struct qelem *q_forw;
+        struct qelem *q_back;
+        char *q_data;
+};
+
+extern kern_return_t map_fd(int fd, vm_offset_t offset,
+        vm_offset_t *addr, boolean_t find_space, vm_size_t numbytes);
+
+
+
+# 12 "QvBasic.h" 2
+
+
+
+
+
+
+
+
+
+
+
+typedef int QvBool;
+
+ 
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+# 4 "QvElement.h" 2
+
+
+class QvNode;
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+
+class QvElement {
+
+  public:
+
+    enum NodeType {
+	 
+	Unknown,
+
+	 
+	OrthographicCamera,
+	PerspectiveCamera,
+
+	 
+	DirectionalLight,
+	PointLight,
+	SpotLight,
+
+	 
+	NoOpTransform,		 
+	MatrixTransform,
+	Rotation,
+	Scale,
+	Transform,
+	Translation,
+
+	 
+	NumNodeTypes,
+    };
+
+    static const char *nodeTypeNames[NumNodeTypes];	 
+
+    int		depth;		 
+    QvElement	*next;		 
+    QvNode	*data;		 
+    NodeType	type;		 
+
+    QvElement();
+    virtual ~QvElement();
+
+     
+    virtual void	print();
+};
+
+
+# 1 "QvTraverse.cpp" 2
+
+# 1 "QvNodes.h" 1
+
+
+
+# 1 "QvCone.h" 1
+
+
+
+# 1 "QvSFBitMask.h" 1
+
+
+
+# 1 "QvSFEnum.h" 1
+
+
+
+# 1 "QvString.h" 1
+
+
+
+
+
+
+class QvString {
+  public:
+    QvString()				{ string = staticStorage; 
+					  string[0] = '\0'; }
+    QvString(const char *str)		{ string = staticStorage;
+					  *this = str; }
+    QvString(const QvString &str)	{ string = staticStorage;
+					  *this = str.string; }
+    ~QvString();
+    u_long		hash()		{ return QvString::hash(string); }
+    int			getLength() const	{ return strlen(string); }
+    void		makeEmpty(QvBool freeOld = 1 );
+    const char *	getString() const	{ return string; }
+    QvString &		operator =(const char *str);
+    QvString &		operator =(const QvString &str)
+	{ return (*this = str.string); }
+    QvString &		operator +=(const char *str);
+    int			operator !() const { return (string[0] == '\0'); }
+    friend int		operator ==(const QvString &str, const char *s);
+   
+    friend int		operator ==(const char *s, const QvString &str)
+	{ return (str == s); }
+    
+    friend int		operator ==(const QvString &str1, const QvString &str2)
+	{ return (str1 == str2.string); }
+    friend int		operator !=(const QvString &str, const char *s);
+    
+    friend int		operator !=(const char *s, const QvString &str)
+	{ return (str != s); }
+    friend int		operator !=(const QvString &str1,
+				    const QvString &str2)
+	{ return (str1 != str2.string); }
+    static u_long	hash(const char *s);    	
+  private:
+    char		*string;
+    int			storageSize;
+
+    char		staticStorage[32 ];
+    void		expand(int bySize);
+};
+
+class QvNameEntry {
+ public:
+    QvBool		isEmpty() const   { return (string[0] == '\0'); }
+    QvBool		isEqual(const char *s) const
+	{ return (string[0] == s[0] && ! strcmp(string, s)); }
+ private:
+    static int		nameTableSize;
+    static QvNameEntry	**nameTable;
+    static struct QvNameChunk *chunk;		
+    const char		*string;
+    u_long		hashValue;
+    QvNameEntry		*next;			
+    static void		initClass();
+    QvNameEntry(const char *s, u_long h, QvNameEntry *n)
+	{ string = s; hashValue = h; next = n; }
+    static const QvNameEntry *	insert(const char *s);
+
+friend class QvName;
+};
+
+class QvName {
+  public:
+    QvName();
+    QvName(const char *s)		{ entry = QvNameEntry::insert(s); }
+    QvName(const QvString &s)	{ entry = QvNameEntry::insert(s.getString()); }
+
+    QvName(const QvName &n)			{ entry = n.entry; }
+    ~QvName()					{}
+    const char		*getString() const	{ return entry->string; }
+    int			getLength() const   { return strlen(entry->string); }
+    static QvBool 	isIdentStartChar(char c);
+    static QvBool	isIdentChar(char c);
+    static QvBool 	isNodeNameStartChar(char c);
+    static QvBool	isNodeNameChar(char c);
+    int			operator !() const   { return entry->isEmpty(); }
+    friend int		operator ==(const QvName &n, const char *s)
+	{ return n.entry->isEqual(s); }
+    friend int		operator ==(const char *s, const QvName &n)
+	{ return n.entry->isEqual(s); }
+    
+    friend int 		operator ==(const QvName &n1, const QvName &n2)
+	{ return n1.entry == n2.entry; }
+    friend int		operator !=(const QvName &n, const char *s)
+	{ return ! n.entry->isEqual(s); }
+    friend int		operator !=(const char *s, const QvName &n)
+	{ return ! n.entry->isEqual(s); }
+    
+    friend int 		operator !=(const QvName &n1, const QvName &n2)
+	{ return n1.entry != n2.entry; }
+  private:
+    const QvNameEntry	*entry;
+};
+
+
+# 4 "QvSFEnum.h" 2
+
+# 1 "QvSubField.h" 1
+
+
+
+# 1 "QvField.h" 1
+
+
+
+
+
+class QvInput;
+class QvNode;
+
+class QvField {
+  public:
+    virtual ~QvField();
+
+    void		setIgnored(QvBool ig)	{ flags.ignored = ig;   }
+    QvBool		isIgnored() const	{ return flags.ignored; }
+
+    QvBool		isDefault() const	{ return flags.hasDefault; }
+
+    QvNode *		getContainer() const	{ return container; }
+
+    void		setDefault(QvBool def)	{ flags.hasDefault = def; }
+    void		setContainer(QvNode *cont);
+    QvBool		read(QvInput *in, const QvName &name);
+
+    QvField()		{ flags.hasDefault = 1 ; flags.ignored = 0 ; }
+
+  public:
+
+  private:
+    struct {
+	unsigned int hasDefault		: 1;  
+	unsigned int ignored		: 1;  
+    }			flags;
+
+    QvNode		*container;
+
+    static QvField *	createInstanceFromName(const QvName &className);
+    virtual QvBool	readValue(QvInput *in) = 0;
+
+friend class QvFieldData;
+};
+
+class QvSField : public QvField {
+  public:
+    virtual ~QvSField();
+
+  protected:
+    QvSField();
+
+  private:
+    virtual QvBool	readValue(QvInput *in) = 0;
+};
+
+class QvMField : public QvField {
+
+  public:
+    int			num;		 
+    int			maxNum;		 
+
+     
+    virtual ~QvMField();
+
+  protected:
+    QvMField();
+    virtual void	makeRoom(int newNum);
+
+  private:
+    virtual void	allocValues(int num) = 0;
+    virtual QvBool	readValue(QvInput *in);
+    virtual QvBool	read1Value(QvInput *in, int index) = 0;
+};
+
+
+# 4 "QvSubField.h" 2
+
+# 1 "QvInput.h" 1
+
+
+
+# 1 "QvDict.h" 1
+
+
+
+
+
+# 1 "QvPList.h" 1
+
+
+
+
+
+class QvPList {
+  public:
+    QvPList();
+    ~QvPList();
+    void	append(void * ptr)
+	{ if (nPtrs + 1 > ptrsSize) expand(nPtrs + 1);
+	  ptrs[nPtrs++] = ptr; }
+    int		find(const void *ptr) const;
+    void	remove(int which);
+    int		getLength() const		{ return (int) nPtrs;	}
+    void	truncate(int start)
+	{ nPtrs = start; }
+    void *&	operator [](int i) const	{ return ptrs[i]; }
+
+  private:
+    void **	ptrs;
+    int		nPtrs;
+    int		ptrsSize;		
+    void	setSize(int size)
+	{ if (size > ptrsSize) expand(size); nPtrs = size; }
+    void	expand(int size);
+};
+
+
+# 6 "QvDict.h" 2
+
+
+class QvDictEntry {
+  private:
+    u_long		key;
+    void *		value;
+    QvDictEntry *	next;
+    QvDictEntry(u_long k, void *v)	{ key = k; value = v; };
+
+friend class QvDict;
+};
+
+class QvDict {
+  public:
+    QvDict( int entries = 251 );
+    ~QvDict();
+    void	clear();
+    QvBool	enter(u_long key, void *value);
+    QvBool	find(u_long key, void *&value) const;
+    QvBool	remove(u_long key);
+
+  private:
+    int			tableSize;
+    QvDictEntry *	*buckets;
+    QvDictEntry *&	findEntry(u_long key) const;
+};
+
+
+# 4 "QvInput.h" 2
+
+
+
+class QvNode;
+class QvDB;
+
+class QvInput {
+ public:
+
+    QvInput();
+    ~QvInput();
+
+    static float	isASCIIHeader(const char *string);
+    void		setFilePointer(FILE *newFP);
+    FILE *		getCurFile() const { return fp; }
+    float		getVersion();
+    QvBool		get(char &c);
+    QvBool		read(char	    &c);
+    QvBool		read(QvString       &s);
+    QvBool		read(QvName	    &n, QvBool validIdent = 0 );
+    QvBool		read(int	    &i);
+    QvBool		read(unsigned int   &i);
+    QvBool		read(short	    &s);
+    QvBool		read(unsigned short &s);
+    QvBool		read(long	    &l);
+    QvBool		read(unsigned long  &l);
+    QvBool		read(float	    &f);
+    QvBool		read(double	    &d);
+    QvBool		eof() const;
+    void		getLocationString(QvString &string) const;
+    void		putBack(char c);
+    void		putBack(const char *string);
+    void		addReference(const QvName &name, QvNode *node);
+    QvNode *		findReference(const QvName &name) const;
+
+  private:
+    FILE		*fp;		 
+    int			lineNum;	 
+    float		version;	 
+    QvBool		readHeader;	 
+    QvBool		headerOk;	 
+    QvDict		refDict;	 
+    QvString		backBuf;
+    int			backBufIndex;		
+
+    QvBool		checkHeader();
+
+    QvBool		skipWhiteSpace();
+
+    QvBool		readInteger(long &l);
+    QvBool		readUnsignedInteger(unsigned long &l);
+    QvBool		readReal(double &d);
+    QvBool		readUnsignedIntegerString(char *str);
+    int			readDigits(char *string);
+    int			readHexDigits(char *string);
+    int			readChar(char *string, char charToRead);
+
+friend class QvNode;
+friend class QvDB;
+};
+
+
+# 5 "QvSubField.h" 2
+
+
+ 
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+# 71 "QvSubField.h"
+
+
+# 5 "QvSFEnum.h" 2
+
+
+class QvSFEnum : public QvSField {
+  public:
+    int value;
+    public:	 QvSFEnum ();	virtual ~ QvSFEnum ();	virtual QvBool readValue(QvInput *in) ;
+
+     
+    void setEnums(int num, const int vals[], const QvName names[])
+	{ numEnums = num; enumValues = vals; enumNames = names; }
+
+    int			numEnums;	 
+    const int		*enumValues;	 
+    const QvName	*enumNames;	 
+
+     
+    QvBool		findEnumValue(const QvName &name, int &val) const;
+};
+
+
+# 37 "QvSFEnum.h"
+
+
+# 4 "QvSFBitMask.h" 2
+
+
+class QvSFBitMask : public QvSFEnum {
+  public:
+     
+    public:	 QvSFBitMask ();	virtual ~ QvSFBitMask ();	virtual QvBool readValue(QvInput *in) ;
+};
+
+
+# 4 "QvCone.h" 2
+
+# 1 "QvSFFloat.h" 1
+
+
+
+
+
+class QvSFFloat : public QvSField {
+  public:
+    float value;
+    public:	 QvSFFloat ();	virtual ~ QvSFFloat ();	virtual QvBool readValue(QvInput *in) ;
+};
+
+
+# 5 "QvCone.h" 2
+
+# 1 "QvSubNode.h" 1
+
+
+
+# 1 "QvFieldData.h" 1
+
+
+
+
+
+
+
+class QvField;
+class QvInput;
+class QvNode;
+
+class QvFieldData {
+  public:
+    QvFieldData() {}
+    ~QvFieldData();
+
+    void		addField(QvNode *defObject, const char *fieldName,
+				 const QvField *field);
+
+    int			getNumFields() const	{ return fields.getLength(); }
+
+    const QvName &	getFieldName(int index) const;
+
+    QvField *		getField(const QvNode *object,
+				 int index) const;
+
+    void		addEnumValue(const char *typeName,
+				     const char *valName, int val);
+    void		getEnumData(const char *typeName, int &num,
+				    const int *&vals, const QvName *&names);
+
+    QvBool		read(QvInput *in, QvNode *object,
+			     QvBool errorOnUnknownField = 1 ) const;
+
+    QvBool		read(QvInput *in, QvNode *object,
+			     const QvName &fieldName,
+			     QvBool &foundName) const;
+
+    QvBool		readFieldTypes(QvInput *in, QvNode *object);
+
+  private:
+    QvPList		fields;
+    QvPList		enums;
+};    
+
+
+# 4 "QvSubNode.h" 2
+
+# 1 "QvNode.h" 1
+
+
+
+
+
+class QvChildList;
+class QvDict;
+class QvFieldData;
+class QvInput;
+class QvNodeList;
+class QvState;
+
+class QvNode {
+
+  public:
+    enum Stage {
+	FIRST_INSTANCE,		 
+	PROTO_INSTANCE,		 
+	OTHER_INSTANCE,		 
+    };
+
+    QvFieldData	*fieldData;
+    QvChildList	*children;
+    QvBool	isBuiltIn;
+
+    QvName		*objName;
+    QvNode();
+    virtual ~QvNode();
+
+    const QvName &	getName() const;
+    void		setName(const QvName &name);
+
+    static void		init();
+    static QvBool	read(QvInput *in, QvNode *&node);
+
+    virtual QvFieldData *getFieldData() = 0;
+
+    virtual void	traverse(QvState *state) = 0;
+
+  protected:
+    virtual QvBool	readInstance(QvInput *in);
+
+  private:
+    static QvDict	*nameDict;
+
+    static void		addName(QvNode *, const char *);
+    static void		removeName(QvNode *, const char *);
+    static QvNode *	readReference(QvInput *in);
+    static QvBool	readNode(QvInput *in, QvName &className,QvNode *&node);
+    static QvBool	readNodeInstance(QvInput *in, const QvName &className,
+					 const QvName &refName, QvNode *&node);
+    static QvNode *	createInstance(QvInput *in, const QvName &className);
+    static QvNode *	createInstanceFromName(const QvName &className);
+    static void		flushInput(QvInput *in);
+};
+
+
+# 5 "QvSubNode.h" 2
+
+
+
+# 16 "QvSubNode.h"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 6 "QvCone.h" 2
+
+
+class QvCone : public QvNode {
+
+    public:	 QvCone :: QvCone ();	virtual ~ QvCone ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+
+    enum Part {			 
+	SIDES	= 0x01,			 
+	BOTTOM	= 0x02,			 
+	ALL	= 0x03		 	 
+    };
+
+     
+    QvSFBitMask		parts;		 
+    QvSFFloat		bottomRadius;	 
+    QvSFFloat		height;		 
+};
+
+
+# 4 "QvNodes.h" 2
+
+# 1 "QvCoordinate3.h" 1
+
+
+
+# 1 "QvMFVec3f.h" 1
+
+
+
+
+
+class QvMFVec3f : public QvMField {
+  public:
+    float *values;
+    public:	 QvMFVec3f ();	virtual ~ QvMFVec3f ();	virtual QvBool	read1Value(QvInput *in, int index);	void		allocValues(int newNum) ;
+};
+
+
+# 4 "QvCoordinate3.h" 2
+
+
+
+class QvCoordinate3 : public QvNode {
+
+    public:	 QvCoordinate3 :: QvCoordinate3 ();	virtual ~ QvCoordinate3 ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+     
+    QvMFVec3f		point;		 
+};
+
+
+# 5 "QvNodes.h" 2
+
+# 1 "QvCube.h" 1
+
+
+
+
+
+
+class QvCube : public QvNode {
+
+    public:	 QvCube :: QvCube ();	virtual ~ QvCube ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+     
+    QvSFFloat		width;		 
+    QvSFFloat		height;		 
+    QvSFFloat		depth;		 
+};
+
+
+# 6 "QvNodes.h" 2
+
+# 1 "QvCylinder.h" 1
+
+
+
+
+
+
+
+class QvCylinder : public QvNode {
+
+    public:	 QvCylinder :: QvCylinder ();	virtual ~ QvCylinder ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+
+    enum Part {			 
+	SIDES	= 0x01,			 
+	TOP	= 0x02,			 
+	BOTTOM	= 0x04,			 
+	ALL	= 0x07,			 
+    };
+
+     
+    QvSFBitMask		parts;		 
+    QvSFFloat		radius;		 
+    QvSFFloat		height;		 
+};
+
+
+# 7 "QvNodes.h" 2
+
+# 1 "QvDirectionalLight.h" 1
+
+
+
+# 1 "QvSFBool.h" 1
+
+
+
+
+
+class QvSFBool : public QvSField {
+  public:
+    QvBool value;
+    public:	 QvSFBool ();	virtual ~ QvSFBool ();	virtual QvBool readValue(QvInput *in) ;
+};
+
+
+# 4 "QvDirectionalLight.h" 2
+
+# 1 "QvSFColor.h" 1
+
+
+
+
+
+class QvSFColor : public QvSField {
+  public:
+    float value[3];
+    public:	 QvSFColor ();	virtual ~ QvSFColor ();	virtual QvBool readValue(QvInput *in) ;
+};
+
+
+# 5 "QvDirectionalLight.h" 2
+
+
+# 1 "QvSFVec3f.h" 1
+
+
+
+
+
+class QvSFVec3f : public QvSField {
+  public:
+    float value[3];
+    public:	 QvSFVec3f ();	virtual ~ QvSFVec3f ();	virtual QvBool readValue(QvInput *in) ;
+};
+
+
+# 7 "QvDirectionalLight.h" 2
+
+
+
+class QvDirectionalLight : public QvNode {
+
+    public:	 QvDirectionalLight :: QvDirectionalLight ();	virtual ~ QvDirectionalLight ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+     
+    QvSFBool		on;		 
+    QvSFFloat		intensity;	 
+    QvSFColor		color;		 
+    QvSFVec3f		direction;	 
+};
+
+
+# 8 "QvNodes.h" 2
+
+# 1 "QvGroup.h" 1
+
+
+
+class QvChildList;
+
+
+class QvGroup : public QvNode {
+
+    public:	 QvGroup :: QvGroup ();	virtual ~ QvGroup ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+    QvNode *		getChild(int index) const;
+    int			getNumChildren() const;
+    virtual QvChildList *getChildren() const;
+    virtual QvBool	readInstance(QvInput *in);
+    virtual QvBool	readChildren(QvInput *in);
+};
+
+
+# 9 "QvNodes.h" 2
+
+# 1 "QvIndexedFaceSet.h" 1
+
+
+
+# 1 "QvMFLong.h" 1
+
+
+
+
+
+class QvMFLong : public QvMField {
+  public:
+    long *values;
+    public:	 QvMFLong ();	virtual ~ QvMFLong ();	virtual QvBool	read1Value(QvInput *in, int index);	void		allocValues(int newNum) ;
+};
+
+
+# 4 "QvIndexedFaceSet.h" 2
+
+
+
+
+
+class QvIndexedFaceSet : public QvNode {
+
+    public:	 QvIndexedFaceSet :: QvIndexedFaceSet ();	virtual ~ QvIndexedFaceSet ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+     
+    QvMFLong		coordIndex;		 
+    QvMFLong		materialIndex;		 
+    QvMFLong		normalIndex;		 
+    QvMFLong		textureCoordIndex;	 
+};
+
+
+# 10 "QvNodes.h" 2
+
+# 1 "QvIndexedLineSet.h" 1
+
+
+
+
+
+
+
+
+class QvIndexedLineSet : public QvNode {
+
+    public:	 QvIndexedLineSet :: QvIndexedLineSet ();	virtual ~ QvIndexedLineSet ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+     
+    QvMFLong		coordIndex;		 
+    QvMFLong		materialIndex;		 
+    QvMFLong		normalIndex;		 
+    QvMFLong		textureCoordIndex;	 
+};
+
+
+# 11 "QvNodes.h" 2
+
+# 1 "QvInfo.h" 1
+
+
+
+# 1 "QvSFString.h" 1
+
+
+
+
+
+class QvSFString : public QvSField {
+  public:
+    QvString value;
+    public:	 QvSFString ();	virtual ~ QvSFString ();	virtual QvBool readValue(QvInput *in) ;
+};
+
+
+# 4 "QvInfo.h" 2
+
+
+
+class QvInfo : public QvNode {
+
+    public:	 QvInfo :: QvInfo ();	virtual ~ QvInfo ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+     
+    QvSFString		string;		 
+};
+
+
+# 12 "QvNodes.h" 2
+
+# 1 "QvLevelOfDetail.h" 1
+
+
+
+# 1 "QvMFFloat.h" 1
+
+
+
+
+
+class QvMFFloat : public QvMField {
+  public:
+    float *values;
+    public:	 QvMFFloat ();	virtual ~ QvMFFloat ();	virtual QvBool	read1Value(QvInput *in, int index);	void		allocValues(int newNum) ;
+};
+
+
+# 4 "QvLevelOfDetail.h" 2
+
+
+
+class QvLevelOfDetail : public QvGroup {
+
+    public:	 QvLevelOfDetail :: QvLevelOfDetail ();	virtual ~ QvLevelOfDetail ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+     
+    QvMFFloat		screenArea;	 
+};
+
+
+# 13 "QvNodes.h" 2
+
+# 1 "QvMaterial.h" 1
+
+
+
+# 1 "QvMFColor.h" 1
+
+
+
+
+
+class QvMFColor : public QvMField {
+  public:
+    float *values;			 
+    public:	 QvMFColor ();	virtual ~ QvMFColor ();	virtual QvBool	read1Value(QvInput *in, int index);	void		allocValues(int newNum) ;
+};
+
+
+# 4 "QvMaterial.h" 2
+
+
+
+
+class QvMaterial : public QvNode {
+
+    public:	 QvMaterial :: QvMaterial ();	virtual ~ QvMaterial ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+     
+    QvMFColor		ambientColor;	 
+    QvMFColor		diffuseColor;	 
+    QvMFColor		specularColor;	 
+    QvMFColor		emissiveColor;	 
+    QvMFFloat		shininess;	 
+    QvMFFloat		transparency;	 
+};
+
+
+# 14 "QvNodes.h" 2
+
+# 1 "QvMaterialBinding.h" 1
+
+
+
+
+
+
+class QvMaterialBinding : public QvNode {
+
+    public:	 QvMaterialBinding :: QvMaterialBinding ();	virtual ~ QvMaterialBinding ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+    enum Binding {
+	DEFAULT,
+	NONE,
+	OVERALL,
+	PER_PART,
+	PER_PART_INDEXED,
+	PER_FACE,
+	PER_FACE_INDEXED,
+	PER_VERTEX,
+	PER_VERTEX_INDEXED,
+    };
+
+     
+    QvSFEnum		value;			
+};
+
+
+# 15 "QvNodes.h" 2
+
+# 1 "QvMatrixTransform.h" 1
+
+
+
+# 1 "QvSFMatrix.h" 1
+
+
+
+
+
+class QvSFMatrix : public QvSField {
+  public:
+    float value[4][4];
+    public:	 QvSFMatrix ();	virtual ~ QvSFMatrix ();	virtual QvBool readValue(QvInput *in) ;
+};
+
+
+# 4 "QvMatrixTransform.h" 2
+
+
+
+class QvMatrixTransform : public QvNode {
+
+    public:	 QvMatrixTransform :: QvMatrixTransform ();	virtual ~ QvMatrixTransform ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+     
+    QvSFMatrix		matrix;		 
+};
+
+
+# 16 "QvNodes.h" 2
+
+# 1 "QvNormal.h" 1
+
+
+
+
+
+
+class QvNormal : public QvNode {
+
+    public:	 QvNormal :: QvNormal ();	virtual ~ QvNormal ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+     
+    QvMFVec3f		vector;		 
+};
+
+
+# 17 "QvNodes.h" 2
+
+# 1 "QvNormalBinding.h" 1
+
+
+
+
+
+
+class QvNormalBinding : public QvNode {
+
+    public:	 QvNormalBinding :: QvNormalBinding ();	virtual ~ QvNormalBinding ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+    enum Binding {
+	DEFAULT,
+	NONE,
+	OVERALL,
+	PER_PART,
+	PER_PART_INDEXED,
+	PER_FACE,
+	PER_FACE_INDEXED,
+	PER_VERTEX,
+	PER_VERTEX_INDEXED,
+    };
+
+     
+    QvSFEnum		value;		 
+};
+
+
+# 18 "QvNodes.h" 2
+
+# 1 "QvOrthographicCamera.h" 1
+
+
+
+
+# 1 "QvSFRotation.h" 1
+
+
+
+
+
+class QvSFRotation : public QvSField {
+  public:
+    float axis[3];
+    float angle;
+    public:	 QvSFRotation ();	virtual ~ QvSFRotation ();	virtual QvBool readValue(QvInput *in) ;
+};
+
+
+# 5 "QvOrthographicCamera.h" 2
+
+
+
+
+class QvOrthographicCamera : public QvNode {
+
+    public:	 QvOrthographicCamera :: QvOrthographicCamera ();	virtual ~ QvOrthographicCamera ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+    QvSFVec3f		position;	 
+    QvSFRotation	orientation;	 
+					 
+    QvSFFloat	    	focalDistance;	 
+					 
+    QvSFFloat		height;		 
+};
+
+
+# 19 "QvNodes.h" 2
+
+# 1 "QvPerspectiveCamera.h" 1
+
+
+
+
+
+
+
+
+class QvPerspectiveCamera : public QvNode {
+
+    public:	 QvPerspectiveCamera :: QvPerspectiveCamera ();	virtual ~ QvPerspectiveCamera ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+    QvSFVec3f		position;	 
+    QvSFRotation	orientation;	 
+					 
+    QvSFFloat	    	focalDistance;	 
+					 
+    QvSFFloat		heightAngle;	 
+					 
+};
+
+
+# 20 "QvNodes.h" 2
+
+# 1 "QvPointLight.h" 1
+
+
+
+
+
+
+
+
+
+class QvPointLight : public QvNode {
+
+    public:	 QvPointLight :: QvPointLight ();	virtual ~ QvPointLight ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+     
+    QvSFBool		on;		 
+    QvSFFloat		intensity;	 
+    QvSFColor		color;		 
+    QvSFVec3f		location;	 
+};
+
+
+# 21 "QvNodes.h" 2
+
+# 1 "QvPointSet.h" 1
+
+
+
+# 1 "QvSFLong.h" 1
+
+
+
+
+
+class QvSFLong : public QvSField {
+  public:
+    long value;
+    public:	 QvSFLong ();	virtual ~ QvSFLong ();	virtual QvBool readValue(QvInput *in) ;
+};
+
+
+# 4 "QvPointSet.h" 2
+
+
+
+
+
+class QvPointSet : public QvNode {
+
+    public:	 QvPointSet :: QvPointSet ();	virtual ~ QvPointSet ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+     
+    QvSFLong		startIndex;	 
+    QvSFLong		numPoints;	 
+};
+
+
+# 22 "QvNodes.h" 2
+
+# 1 "QvRotation.h" 1
+
+
+
+
+
+
+class QvRotation : public QvNode {
+
+    public:	 QvRotation :: QvRotation ();	virtual ~ QvRotation ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+     
+    QvSFRotation	rotation;	 
+};
+
+
+# 23 "QvNodes.h" 2
+
+# 1 "QvScale.h" 1
+
+
+
+
+
+
+class QvScale : public QvNode {
+
+    public:	 QvScale :: QvScale ();	virtual ~ QvScale ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+     
+    QvSFVec3f		scaleFactor;	 
+};
+
+
+# 24 "QvNodes.h" 2
+
+# 1 "QvSeparator.h" 1
+
+
+
+
+
+
+
+
+class QvSeparator : public QvGroup {
+
+    public:	 QvSeparator :: QvSeparator ();	virtual ~ QvSeparator ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+    enum CullEnabled {		 
+	OFF,			 
+	ON,			 
+	AUTO,			 
+    };
+
+     
+    QvSFEnum renderCulling;
+};
+
+
+# 25 "QvNodes.h" 2
+
+# 1 "QvShapeHints.h" 1
+
+
+
+
+
+
+
+class QvShapeHints : public QvNode {
+
+    public:	 QvShapeHints :: QvShapeHints ();	virtual ~ QvShapeHints ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+    enum VertexOrdering {
+	UNKNOWN_ORDERING,
+	CLOCKWISE,
+	COUNTERCLOCKWISE,
+    };
+
+    enum ShapeType {
+	UNKNOWN_SHAPE_TYPE,
+	SOLID,
+    };
+
+    enum FaceType {
+	UNKNOWN_FACE_TYPE,
+	CONVEX,
+    };
+
+     
+    QvSFEnum		vertexOrdering;	 
+    QvSFEnum		shapeType;	 
+    QvSFEnum		faceType;	 
+    QvSFFloat		creaseAngle;	 
+};
+
+
+# 26 "QvNodes.h" 2
+
+# 1 "QvSphere.h" 1
+
+
+
+
+
+
+class QvSphere : public QvNode {
+
+    public:	 QvSphere :: QvSphere ();	virtual ~ QvSphere ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+     
+    QvSFFloat		radius;		 
+};
+
+
+
+# 27 "QvNodes.h" 2
+
+# 1 "QvSpotLight.h" 1
+
+
+
+
+
+
+
+
+
+class QvSpotLight : public QvNode {
+
+    public:	 QvSpotLight :: QvSpotLight ();	virtual ~ QvSpotLight ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+     
+    QvSFBool	on;		 
+    QvSFFloat	intensity;	 
+    QvSFColor	color;		 
+    QvSFVec3f	location;	 
+    QvSFVec3f	direction;	 
+    QvSFFloat	dropOffRate;	 
+				 
+				 
+    QvSFFloat	cutOffAngle;	 
+				 
+				 
+};
+
+
+# 28 "QvNodes.h" 2
+
+# 1 "QvSwitch.h" 1
+
+
+
+
+
+
+
+
+
+class QvSwitch : public QvGroup {
+
+    public:	 QvSwitch :: QvSwitch ();	virtual ~ QvSwitch ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+     
+    QvSFLong		whichChild;	 
+};
+
+
+# 29 "QvNodes.h" 2
+
+# 1 "QvTexture2.h" 1
+
+
+
+
+# 1 "QvSFImage.h" 1
+
+
+
+
+
+class QvSFImage : public QvSField {
+  public:
+    short		size[2];	 
+    int			numComponents;	 
+    unsigned char *	bytes;		 
+    public:	 QvSFImage ();	virtual ~ QvSFImage ();	virtual QvBool readValue(QvInput *in) ;
+};
+
+
+# 5 "QvTexture2.h" 2
+
+
+
+
+class QvTexture2 : public QvNode {
+
+    public:	 QvTexture2 :: QvTexture2 ();	virtual ~ QvTexture2 ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+    enum Wrap {				 
+	REPEAT,
+	CLAMP,
+    };
+
+     
+    QvSFString		filename;	 
+    QvSFImage		image;		 
+    QvSFEnum		wrapS;
+    QvSFEnum		wrapT;
+
+    virtual QvBool	readInstance(QvInput *in);
+    QvBool		readImage();
+};
+
+
+# 30 "QvNodes.h" 2
+
+# 1 "QvTexture2Transform.h" 1
+
+
+
+
+# 1 "QvSFVec2f.h" 1
+
+
+
+
+
+class QvSFVec2f : public QvSField {
+  public:
+    float value[2];
+    public:	 QvSFVec2f ();	virtual ~ QvSFVec2f ();	virtual QvBool readValue(QvInput *in) ;
+};
+
+
+# 5 "QvTexture2Transform.h" 2
+
+
+
+class QvTexture2Transform : public QvNode {
+
+    public:	 QvTexture2Transform :: QvTexture2Transform ();	virtual ~ QvTexture2Transform ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+     
+    QvSFVec2f		translation;	 
+    QvSFFloat		rotation;	 
+    QvSFVec2f		scaleFactor;	 
+    QvSFVec2f		center;	         
+};
+
+
+# 31 "QvNodes.h" 2
+
+# 1 "QvTextureCoordinate2.h" 1
+
+
+
+# 1 "QvMFVec2f.h" 1
+
+
+
+
+
+class QvMFVec2f : public QvMField {
+  public:
+    float *values;
+    public:	 QvMFVec2f ();	virtual ~ QvMFVec2f ();	virtual QvBool	read1Value(QvInput *in, int index);	void		allocValues(int newNum) ;
+};
+
+
+# 4 "QvTextureCoordinate2.h" 2
+
+
+
+class QvTextureCoordinate2 : public QvNode {
+
+    public:	 QvTextureCoordinate2 :: QvTextureCoordinate2 ();	virtual ~ QvTextureCoordinate2 ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+     
+    QvMFVec2f		point;		 
+};
+
+
+# 32 "QvNodes.h" 2
+
+# 1 "QvTransform.h" 1
+
+
+
+
+
+
+
+class QvTransform : public QvNode {
+
+    public:	 QvTransform :: QvTransform ();	virtual ~ QvTransform ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+     
+    QvSFVec3f		translation;	  
+    QvSFRotation	rotation;	  
+    QvSFVec3f		scaleFactor;	  
+    QvSFRotation	scaleOrientation; 
+    QvSFVec3f		center;	          
+};
+
+
+# 33 "QvNodes.h" 2
+
+# 1 "QvTransformSeparator.h" 1
+
+
+
+
+
+class QvTransformSeparator : public QvGroup {
+
+    public:	 QvTransformSeparator :: QvTransformSeparator ();	virtual ~ QvTransformSeparator ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+     
+};
+
+
+# 34 "QvNodes.h" 2
+
+# 1 "QvTranslation.h" 1
+
+
+
+
+
+
+class QvTranslation : public QvNode {
+
+    public:	 QvTranslation :: QvTranslation ();	virtual ~ QvTranslation ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+     
+    QvSFVec3f		translation;	 
+};
+
+
+# 35 "QvNodes.h" 2
+
+# 1 "QvWWWAnchor.h" 1
+
+
+
+
+
+
+
+class QvWWWAnchor : public QvGroup {
+
+    public:	 QvWWWAnchor :: QvWWWAnchor ();	virtual ~ QvWWWAnchor ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+
+    enum Map {			 
+	NONE,				 
+	POINT,				 
+    };
+
+     
+    QvSFString		name;		 
+    QvSFEnum		map;		 
+};
+
+
+# 36 "QvNodes.h" 2
+
+# 1 "QvWWWInline.h" 1
+
+
+
+
+
+
+
+class QvWWWInline : public QvGroup {
+
+    public:	 QvWWWInline :: QvWWWInline ();	virtual ~ QvWWWInline ();	virtual void	traverse(QvState *state);	private:	static QvBool	firstInstance;	static QvFieldData	*fieldData;	virtual QvFieldData *getFieldData() { return fieldData; } ;
+
+  public:
+     
+    QvSFString		name;		 
+    QvSFVec3f		bboxSize;	 
+    QvSFVec3f		bboxCenter;	 
+};
+
+
+# 37 "QvNodes.h" 2
+
+
+
+# 2 "QvTraverse.cpp" 2
+
+# 1 "QvState.h" 1
+
+
+
+
+
+ 
+# 1 "../BspLib/VrmlFile.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+# 1 "../BspLib/BspLibDefs.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+
+ 
+# 1 "/usr/include/ctype.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/usr/include/runetype.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+typedef struct {
+	rune_t		min;		 
+	rune_t		max;		 
+	rune_t		map;		 
+	unsigned long	*types;		 
+} _RuneEntry;
+
+typedef struct {
+	int		nranges;	 
+	_RuneEntry	*ranges;	 
+} _RuneRange;
+
+typedef struct {
+	char		magic[8];	 
+	char		encoding[32];	 
+
+	rune_t		(*sgetrune)
+	     (const char *, unsigned int, char const **)  ;
+	int		(*sputrune)
+	     (rune_t, char *, unsigned int, char **)  ;
+	rune_t		invalid_rune;
+
+	unsigned long	runetype[(1 <<8 ) ];
+	rune_t		maplower[(1 <<8 ) ];
+	rune_t		mapupper[(1 <<8 ) ];
+
+	 
+
+
+
+
+	_RuneRange	runetype_ext;
+	_RuneRange	maplower_ext;
+	_RuneRange	mapupper_ext;
+
+	void		*variable;	 
+	int		variable_len;	 
+} _RuneLocale;
+
+
+
+extern _RuneLocale _DefaultRuneLocale;
+extern _RuneLocale *_CurrentRuneLocale;
+
+
+# 68 "/usr/include/ctype.h" 2 3 4
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+extern "C" { 
+unsigned long	___runetype  (__wchar_t )  ;
+__wchar_t 	___tolower  (__wchar_t )  ;
+__wchar_t 	___toupper  (__wchar_t )  ;
+} 
+
+ 
+
+
+
+
+
+
+
+
+
+static inline  int
+__istype(__wchar_t  c, unsigned long f)
+{
+	return((((c & (~((1 <<8 )  - 1)) ) ? ___runetype(c) :
+	    _CurrentRuneLocale->runetype[c]) & f) ? 1 : 0);
+}
+
+static inline  int
+__isctype(__wchar_t  c, unsigned long f)
+{
+	return((((c & (~((1 <<8 )  - 1)) ) ? 0 :
+	    _DefaultRuneLocale.runetype[c]) & f) ? 1 : 0);
+}
+
+ 
+
+static inline  __wchar_t 
+toupper(__wchar_t  c)
+{
+	return((c & (~((1 <<8 )  - 1)) ) ?
+	    ___toupper(c) : _CurrentRuneLocale->mapupper[c]);
+}
+
+static inline  __wchar_t 
+tolower(__wchar_t  c)
+{
+	return((c & (~((1 <<8 )  - 1)) ) ?
+	    ___tolower(c) : _CurrentRuneLocale->maplower[c]);
+}
+
+
+# 166 "/usr/include/ctype.h" 3 4
+
+
+
+# 13 "../BspLib/BspLibDefs.h" 2
+
+# 1 "/usr/include/errno.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/usr/include/sys/errno.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+extern "C" { 
+extern int * __error  (void)  ;
+
+} 
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+					 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+ 
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+ 
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 22 "/usr/include/errno.h" 2 3 4
+
+
+# 14 "../BspLib/BspLibDefs.h" 2
+
+# 1 "/usr/include/limits.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/usr/include/gcc/darwin/2.95.2/g++/../machine/limits.h" 1 3
+# 10 "/usr/include/gcc/darwin/2.95.2/g++/../machine/limits.h" 3
+
+# 108 "/usr/include/gcc/darwin/2.95.2/g++/../machine/limits.h" 3
+
+# 62 "/usr/include/limits.h" 2 3 4
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 15 "../BspLib/BspLibDefs.h" 2
+
+# 1 "/usr/include/math.h" 1 3 4
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+extern int signgam;
+
+
+enum fdversion {fdlibm_ieee = -1, fdlibm_svid, fdlibm_xopen, fdlibm_posix};
+
+
+
+
+ 
+
+
+
+
+
+ 
+extern  enum fdversion   _fdlib_version ;
+
+
+
+
+
+
+# 91 "/usr/include/math.h" 3 4
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+extern "C" { 
+ 
+
+
+extern   double acos  (double)  ;
+extern   double asin  (double)  ;
+extern   double atan  (double)  ;
+extern   double atan2  (double, double)  ;
+extern   double cos  (double)  ;
+extern   double sin  (double)  ;
+extern   double tan  (double)  ;
+
+extern   double cosh  (double)  ;
+extern   double sinh  (double)  ;
+extern   double tanh  (double)  ;
+
+extern   double exp  (double)  ;
+extern double frexp  (double, int *)  ;
+extern   double ldexp  (double, int)  ;
+extern   double log  (double)  ;
+extern   double log10  (double)  ;
+extern double modf  (double, double *)  ;
+
+extern   double pow  (double, double)  ;
+extern   double sqrt  (double)  ;
+
+extern   double ceil  (double)  ;
+extern   double fabs  (double)  ;
+extern   double floor  (double)  ;
+extern   double fmod  (double, double)  ;
+
+
+extern   double erf  (double)  ;
+extern   double erfc  (double)  ;
+extern double gamma  (double)  ;
+extern   double hypot  (double, double)  ;
+extern   int isinf  (double)  ;
+extern   int isnan  (double)  ;
+extern    int finite  (double)  ;
+extern   double j0  (double)  ;
+extern   double j1  (double)  ;
+extern   double jn  (int, double)  ;
+extern double lgamma  (double)  ;
+extern   double y0  (double)  ;
+extern   double y1  (double)  ;
+extern   double yn  (int, double)  ;
+
+
+extern   double acosh  (double)  ;
+extern   double asinh  (double)  ;
+extern   double atanh  (double)  ;
+extern   double cbrt  (double)  ;
+extern   double logb  (double)  ;
+extern   double nextafter  (double, double)  ;
+extern   double remainder  (double, double)  ;
+extern   double scalb  (double, int)  ;
+
+
+
+
+
+ 
+
+
+extern   double significand  (double)  ;
+
+ 
+
+
+extern   double copysign  (double, double)  ;
+extern   int ilogb  (double)  ;
+extern   double rint  (double)  ;
+extern   double scalbn  (double, int)  ;
+
+ 
+
+
+extern double cabs();
+extern   double drem  (double, double)  ;
+extern   double expm1  (double)  ;
+extern   double log1p  (double)  ;
+
+ 
+
+
+
+
+
+
+
+
+
+} 
+
+
+# 16 "../BspLib/BspLibDefs.h" 2
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+ 
+
+
+
+ 
+typedef unsigned char			byte;
+typedef unsigned short			word;
+typedef unsigned long			dword;
+
+ 
+typedef long					fixed_t;
+typedef float					float_t;
+typedef double					hprec_t;
+
+ 
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+namespace BspLib  { 
+
+
+ 
+struct ColorRGB {
+	byte R;
+	byte G;
+	byte B;
+};
+
+ 
+struct ColorRGBA {
+	byte R;
+	byte G;
+	byte B;
+	byte A;
+};
+
+ 
+struct ColorRGBf {
+	float R;
+	float G;
+	float B;
+};
+
+ 
+struct ColorRGBAf {
+	float R;
+	float G;
+	float B;
+	float A;
+};
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+class EpsAreas {
+
+public:
+	static double eps_scalarproduct;		 
+	static double eps_vanishcomponent;		 
+	static double eps_vanishdenominator;	 
+	static double eps_planethickness;		 
+	static double eps_pointonline;			 
+	static double eps_pointonlineseg;		 
+	static double eps_vertexmergearea;		 
+};
+
+
+} 
+
+
+
+
+# 12 "../BspLib/VrmlFile.h" 2
+
+# 1 "../BspLib/BoundingBox.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+# 1 "../BspLib/BspObject.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+# 1 "../BspLib/SystemIO.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+
+ 
+
+
+
+
+
+namespace BspLib  { 
+
+
+ 
+ 
+class SystemIO {
+
+public:
+
+	 
+	enum {
+		SYSTEM_IO_OK		= 0x0000,
+		SYSTEM_IO_ERROR		= 0x0001,
+		END_OF_FILE			= 0x0002,
+		FILE_NOT_FOUND		= 0x0003,
+		FILE_READ_ERROR		= 0x0004,
+		FILE_WRITE_ERROR	= 0x0005,
+		FILE_CLOSED			= 0x0006,
+		FILE_ALREADY_OPEN	= 0x0007,
+	};
+
+	 
+	enum {
+		CRITERR_ALLOW_RET	= 0x0001,
+	};
+
+	 
+	enum {
+		CHECK_ERRORS		= 0x0001,
+	};
+
+public:
+	static void InfoMessage( char *message );
+	static void ErrorMessage( char *message );
+	static void HandleCriticalError( int flags = 0 );
+	static void SetProgramName( const char *name );
+	static void SetInfoMessageCallback( void (*callb)(char*) );
+	static void SetErrorMessageCallback( void (*callb)(char*) );
+	static void SetCriticalErrorCallback( int (*callb)(int) );
+
+
+
+
+
+public:
+	static const char	version_str[];
+
+private:
+	static const char	*program_name;
+	static void			(*infomessage_callback)(char*);
+	static void			(*errormessage_callback)(char*);
+	static int			(*criticalerror_callback)(int);
+
+
+
+
+
+
+protected:
+
+
+ 
+class FilePtr {
+
+public:
+	FilePtr( const char *fname, const char *mode ) { fp = fopen( fname, mode ); }
+	~FilePtr() { if ( fp ) fclose( fp ); }
+
+	operator FILE*() { return fp; }
+
+protected:
+	FILE *fp;
+
+};  
+
+
+ 
+class FileAccess : public FilePtr {
+
+public:
+	FileAccess( const char *fname, const char *mode, int flags = CHECK_ERRORS );
+	~FileAccess();
+
+	int ReOpen( const char *fname, const char *mode, int flags = CHECK_ERRORS );
+	int	Close();
+
+	int Read( void *buffer, size_t size, size_t count, int flags = 0 );
+	int Write( void *buffer, size_t size, size_t count, int flags = 0 );
+
+	char *ReadLine( char *line, int maxlen, int flags = 0 );
+	char *WriteLine( char *line, int flags = 0 );
+
+	int Status() { return status; }
+
+	char *getFileName() { return filename; }
+
+private:
+	void IOError( int errorcode );
+
+private:
+	char *filename;
+	int  status;
+
+};  
+
+
+ 
+class StrScratch {
+
+public:
+	StrScratch() { line = new char[ 1024 ]; }
+	~StrScratch() { delete line; }
+
+	operator char*() { return line; }
+
+private:
+	char *line;
+
+};  
+
+
+};  
+
+
+ 
+ 
+class String {
+
+public:
+	String() { data = 0 ; }
+	String( const char *src );
+	~String() { delete data; }
+
+	String( const String& copyobj );
+	String& operator =( const String& copyobj );
+
+	operator char*() { return data; }
+
+	int IsNULL() const { return ( data == 0  ); }
+	int IsEmpty() const { return data ? ( *data == '\0' ) : 1 ; }
+
+	int getLength() const { return data ? strlen( data ) : 0; }
+
+private:
+	char *data;
+};
+
+
+} 
+
+
+
+
+# 13 "../BspLib/BspObject.h" 2
+
+# 1 "../BspLib/Chunk.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+
+
+
+ 
+ 
+
+ 
+
+
+ 
+ 
+
+
+namespace BspLib  { 
+
+
+ 
+template<class T> class Chunk;
+
+
+ 
+ 
+template<class T>
+class ChunkRep : public virtual SystemIO {
+
+	friend class Chunk<T>;
+
+	 
+	enum {
+		E_INVALIDINDX
+	};
+
+	void		Error( int err ) const;
+
+private:
+	ChunkRep( int chunksize = 0 );
+	~ChunkRep();
+
+	int			AddElement( const T& element );
+	T&			FetchElement( int index );
+
+	int			getNumElements() const;
+
+private:
+	int			ref_count;
+	int			numelements;
+	int			maxnumelements;
+	T*			elements;
+	ChunkRep*	next;
+
+	static const int CHUNK_SIZE;
+};
+
+
+ 
+ 
+template<class T>
+ChunkRep<T>::ChunkRep( int chunksize ) : ref_count( 0 )
+{
+	int challocsize	= chunksize > 0 ? chunksize : CHUNK_SIZE;
+	elements		= new T[ challocsize ];
+	maxnumelements	= challocsize;
+	numelements		= 0;
+	next			= 0 ;
+}
+
+
+ 
+ 
+template<class T>
+ChunkRep<T>::~ChunkRep()
+{
+	delete[] elements;
+	delete next;
+}
+
+
+ 
+ 
+template<class T>
+void ChunkRep<T>::Error( int err ) const
+{
+	{
+	StrScratch message;
+	sprintf( message, "***ERROR*** in object of a class of template Chunk" );
+
+	switch ( err ) {
+
+	case E_INVALIDINDX:
+		sprintf( message + strlen( message ), ": [Invalid index]" );
+		break;
+	}
+
+	ErrorMessage( message );
+	}
+
+	HandleCriticalError();
+}
+
+
+ 
+ 
+template<class T>
+T& ChunkRep<T>::FetchElement( int index )
+{
+
+# 133 "../BspLib/Chunk.h"
+
+
+	if ( index >= numelements )
+		Error( E_INVALIDINDX );
+
+	 
+	return elements[ index ];
+
+
+
+}
+
+
+ 
+ 
+template<class T>
+int ChunkRep<T>::AddElement( const T& element )
+{
+
+# 185 "../BspLib/Chunk.h"
+
+
+	 
+	if ( numelements == maxnumelements ) {
+
+
+		maxnumelements *= 2;
+
+
+
+		T *temp = new T[ maxnumelements ];
+
+
+
+
+		for ( int i = 0; i < numelements; i++ )
+			temp[ i ] = elements[ i ];
+
+		delete[] elements;
+		elements = temp;
+	}
+
+	elements[ numelements ] = element;
+	return numelements++;
+
+
+
+}
+
+
+ 
+ 
+template<class T>
+int ChunkRep<T>::getNumElements() const
+{
+	int num = 0;
+	for ( const ChunkRep *vlist = this; vlist; vlist = vlist->next )
+		num += vlist->numelements;
+	return num;
+}
+
+
+ 
+ 
+template<class T>
+class Chunk {
+
+public:
+	Chunk( int chunksize = 0 ) { rep = new ChunkRep<T>( chunksize ); rep->ref_count = 1; }
+	~Chunk() { if ( --rep->ref_count == 0 ) delete rep; }
+
+	Chunk( const Chunk& copyobj );
+	Chunk& operator =( const Chunk& copyobj );
+
+	T&				operator []( int index ) { return rep->FetchElement( index ); }
+	T&				FetchElement( int index ) { return rep->FetchElement( index ); }
+	int				AddElement( const T& element ) { return rep->AddElement( element ); }
+
+	int				getNumElements() const { return rep->getNumElements(); }
+
+private:
+	ChunkRep<T>*	rep;
+};
+
+
+ 
+ 
+template<class T>
+Chunk<T>::Chunk( const Chunk<T>& copyobj )
+{
+	rep = copyobj.rep;
+	rep->ref_count++;
+}
+
+
+ 
+ 
+template<class T>
+Chunk<T>& Chunk<T>::operator =( const Chunk<T>& copyobj )
+{
+	if ( &copyobj != this ) {
+		if ( --rep->ref_count == 0 ) {
+			delete rep;
+		}
+		rep = copyobj.rep;
+		rep->ref_count++;
+	}
+	return *this;
+}
+
+
+} 
+
+
+
+
+# 14 "../BspLib/BspObject.h" 2
+
+# 1 "../BspLib/Face.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+
+# 1 "../BspLib/Material.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+
+
+
+namespace BspLib  { 
+
+
+ 
+ 
+class Material {
+
+public:
+	Material() { }
+	~Material() { }
+
+	ColorRGBA	getAmbientColor()	{ return ambientcolor; }
+	ColorRGBA	getDiffuseColor()	{ return diffusecolor; }
+	ColorRGBA	getSpecularColor()	{ return specularcolor; }
+	ColorRGBA	getEmissiveColor()	{ return emissivecolor; }
+
+	void		setAmbientColor( ColorRGBA col )  { ambientcolor = col; ambientcolor.A = 255; }
+	void		setDiffuseColor( ColorRGBA col )  { diffusecolor = col; diffusecolor.A = 255; }
+	void		setSpecularColor( ColorRGBA col ) { specularcolor = col; specularcolor.A = 255; }
+	void		setEmissiveColor( ColorRGBA col ) { emissivecolor = col; emissivecolor.A = 255; }
+
+	float		getShininess()		{ return shininess; }
+	float		getTransparency()	{ return transparency; }
+
+	void		setShininess( float s )		{ shininess = s; }
+	void		setTransparency( float t )	{ transparency = t; }
+
+private:
+	ColorRGBA	ambientcolor;	 
+	ColorRGBA	diffusecolor;
+	ColorRGBA	specularcolor;
+	ColorRGBA	emissivecolor;
+	float		shininess;
+	float		transparency;
+};
+
+
+} 
+
+
+
+
+# 14 "../BspLib/Face.h" 2
+
+# 1 "../BspLib/Plane.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+# 1 "../BspLib/Vertex.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+
+
+namespace BspLib  { 
+
+
+ 
+ 
+class Vertex3 {
+
+	friend class Vector3;
+	friend class LineSeg3;
+
+	friend int operator ==( const Vertex3 v1, const Vertex3 v2 );
+	friend int operator !=( const Vertex3 v1, const Vertex3 v2 );
+
+	friend Vector3 operator -( const Vertex3 v1, const Vertex3 v2 );
+
+	friend Vertex3 operator +( const Vertex3 v1, const Vector3 v2 );
+	friend Vertex3 operator +( const Vector3 v1, const Vertex3 v2 );
+	friend Vertex3 operator -( const Vertex3 v1, const Vector3 v2 );
+
+public:
+	Vertex3( hprec_t x = 0, hprec_t y = 0, hprec_t z = 0, hprec_t w = 1.0 );
+	~Vertex3() { }
+
+	Vertex3& operator +=( const Vector3 v );
+	Vertex3& operator -=( const Vector3 v );
+
+	int  IsInVicinity( const Vertex3& vertex ) const;
+	void ChangeAxes( const char *xchangecmd, const Vertex3& ads );
+
+	hprec_t getX() const { return X; }
+	hprec_t getY() const { return Y; }
+	hprec_t getZ() const { return Z; }
+ 	hprec_t getW() const { return W; }
+
+	void setX( hprec_t x ) { X = x; }
+	void setY( hprec_t y ) { Y = y; }
+	void setZ( hprec_t z ) { Z = z; }
+	void setW( hprec_t w ) { W = w; }
+
+private:
+	void ChangeAxis( const char xchar, const hprec_t src );
+
+protected:
+	hprec_t X;
+	hprec_t Y;
+	hprec_t Z;
+	hprec_t W;
+};
+
+
+ 
+ 
+class Vector3 : public Vertex3 {
+
+	friend class LineSeg3;
+
+	friend Vector3 operator -( const Vertex3 v1, const Vertex3 v2 );
+
+	friend Vertex3 operator +( const Vertex3 v1, const Vector3 v2 );
+	friend Vertex3 operator +( const Vector3 v1, const Vertex3 v2 );
+	friend Vertex3 operator -( const Vertex3 v1, const Vector3 v2 );
+
+	friend Vector3 operator +( const Vector3 v1, const Vector3 v2 );
+	friend Vector3 operator -( const Vector3 v1, const Vector3 v2 );
+
+	friend Vector3 operator *( const Vector3 v1, double t );
+	friend Vector3 operator *( double t, const Vector3 v1 );
+
+public:
+	Vector3( hprec_t x = 0, hprec_t y = 0, hprec_t z = 0, hprec_t w = 1.0 )
+		: Vertex3( x, y, z, w ) { }
+	 
+	Vector3( const Vertex3& v1, const Vertex3& v2 )
+		: Vertex3( v2.X - v1.X, v2.Y - v1.Y, v2.Z - v1.Z ) { }
+	 
+	Vector3( const Vector3& v1, const Vector3& v2 );
+	 
+	Vector3( const Vertex3& vtx ) { *(Vertex3*)this = vtx; }
+	~Vector3() { }
+
+	Vector3& operator +=( const Vector3 v );
+	Vector3& operator -=( const Vector3 v );
+
+	Vector3& operator *=( double t );
+
+	int			Normalize();
+	int			Homogenize();
+	int			IsNullVector() const;
+	hprec_t		VecLength() const;
+	hprec_t		DotProduct( const Vector3& vect ) const;
+	void		CrossProduct( const Vector3& vect1, const Vector3& vect2 );
+	void		CreateDirVec( const Vertex3& vertex1, const Vertex3& vertex2 );
+};
+
+
+ 
+ 
+class Vertex2 {
+
+	friend class Vector2;
+	friend class LineSeg2;
+
+	friend int operator ==( const Vertex2 v1, const Vertex2 v2 );
+	friend int operator !=( const Vertex2 v1, const Vertex2 v2 );
+
+	friend Vector2 operator -( const Vertex2 v1, const Vertex2 v2 );
+
+	friend Vertex2 operator +( const Vertex2 v1, const Vector2 v2 );
+	friend Vertex2 operator +( const Vector2 v1, const Vertex2 v2 );
+	friend Vertex2 operator -( const Vertex2 v1, const Vector2 v2 );
+
+public:
+	Vertex2( hprec_t x = 0, hprec_t y = 0, hprec_t w = 1.0 ) { X = x; Y = y; W = w; }
+	 
+	Vertex2( const Vector2& vect );
+	~Vertex2() { }
+
+	Vertex2& operator +=( const Vector2 v );
+	Vertex2& operator -=( const Vector2 v );
+
+	int  IsInVicinity( const Vertex2& vertex ) const;
+	void InitFromVertex3( const Vertex3& vertex );
+
+	hprec_t getX() const { return X; }
+	hprec_t getY() const { return Y; }
+ 	hprec_t getW() const { return W; }
+
+	void setX( hprec_t x ) { X = x; }
+	void setY( hprec_t y ) { Y = y; }
+	void setW( hprec_t w ) { W = w; }
+
+protected:
+	hprec_t X;
+	hprec_t Y;
+	hprec_t W;
+};
+
+
+ 
+ 
+class Vector2 : public Vertex2 {
+
+	friend class LineSeg2;
+
+	friend Vector2 operator -( const Vertex2 v1, const Vertex2 v2 );
+
+	friend Vertex2 operator +( const Vertex2 v1, const Vector2 v2 );
+	friend Vertex2 operator +( const Vector2 v1, const Vertex2 v2 );
+	friend Vertex2 operator -( const Vertex2 v1, const Vector2 v2 );
+
+	friend Vector2 operator +( const Vector2 v1, const Vector2 v2 );
+	friend Vector2 operator -( const Vector2 v1, const Vector2 v2 );
+
+	friend Vector2 operator *( const Vector2 v1, double t );
+	friend Vector2 operator *( double t, const Vector2 v1 );
+
+public:
+	Vector2( hprec_t x = 0, hprec_t y = 0, hprec_t w = 1.0 )
+		: Vertex2( x, y, w ) { }
+	 
+	Vector2( const Vertex2& v1, const Vertex2& v2 )
+		: Vertex2( v2.X - v1.X, v2.Y - v1.Y ) { }
+	 
+	Vector2( const Vertex2& vtx ) { *(Vertex2*)this = vtx; }
+	~Vector2() { }
+
+	Vector2& operator +=( const Vector2 v );
+	Vector2& operator -=( const Vector2 v );
+
+	Vector2& operator *=( double t );
+
+	int			Normalize();
+	int			Homogenize();
+	int			IsNullVector() const;
+	hprec_t		VecLength() const;
+	hprec_t		DotProduct( const Vector2& vect ) const;
+	void		CreateDirVec( const Vertex2& vertex, const Vertex2& dirvec );
+};
+
+
+} 
+
+
+ 
+# 1 "../BspLib/Vector.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+# 1 "../BspLib/Vector3.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+# 1 "../BspLib/Vertex3.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+
+
+namespace BspLib  { 
+
+
+ 
+inline Vertex3::Vertex3( hprec_t x, hprec_t y, hprec_t z, hprec_t w )
+{
+	X = x;
+	Y = y;
+	Z = z;
+	W = w;
+}
+
+ 
+inline int operator ==( const Vertex3 v1, const Vertex3 v2 )
+{
+	return ( ( v1.X == v2.X ) && ( v1.Y == v2.Y ) && ( v1.Z == v2.Z ) && ( v1.W == v2.W ) );
+}
+
+ 
+inline int operator !=( const Vertex3 v1, const Vertex3 v2 )
+{
+	return ( ( v1.X != v2.X ) || ( v1.Y != v2.Y ) || ( v1.Z != v2.Z ) || ( v1.W != v2.W ) );
+}
+
+ 
+inline Vertex3& Vertex3::operator +=( const Vector3 v )
+{
+	X += v.X;
+	Y += v.Y;
+	Z += v.Z;
+
+	return *this;
+}
+
+ 
+inline Vertex3& Vertex3::operator -=( const Vector3 v )
+{
+	X -= v.X;
+	Y -= v.Y;
+	Z -= v.Z;
+
+	return *this;
+}
+
+ 
+inline int Vertex3::IsInVicinity( const Vertex3& vertex ) const
+{
+	return ( ( fabs( X - vertex.X ) < EpsAreas::eps_vertexmergearea  ) &&
+			 ( fabs( Y - vertex.Y ) < EpsAreas::eps_vertexmergearea  ) &&
+			 ( fabs( Z - vertex.Z ) < EpsAreas::eps_vertexmergearea  ) );
+}
+
+
+} 
+
+
+
+
+# 13 "../BspLib/Vector3.h" 2
+
+
+
+namespace BspLib  { 
+
+
+ 
+inline Vector3 operator *( const Vector3 v1, double t )
+{
+	return Vector3( v1.X * t, v1.Y * t, v1.Z * t, 1.0 );
+}
+
+ 
+inline Vector3 operator *( double t, const Vector3 v1 )
+{
+	return Vector3( v1.X * t, v1.Y * t, v1.Z * t, 1.0 );
+}
+
+ 
+inline Vector3::Vector3( const Vector3& v1, const Vector3& v2 )
+{
+	CrossProduct( v1, v2 );
+}
+
+ 
+inline Vector3& Vector3::operator +=( const Vector3 v )
+{
+	X += v.X;
+	Y += v.Y;
+	Z += v.Z;
+	return *this;
+}
+
+ 
+inline Vector3& Vector3::operator -=( const Vector3 v )
+{
+	X -= v.X;
+	Y -= v.Y;
+	Z -= v.Z;
+	return *this;
+}
+
+ 
+inline Vector3& Vector3::operator *=( double t )
+{
+	X *= t;
+	Y *= t;
+	Z *= t;
+	return *this;
+}
+
+ 
+inline int Vector3::Normalize()
+{
+	if ( IsNullVector() )
+		return 0 ;
+
+	double oonorm = 1 / VecLength();
+	X = X * oonorm;
+	Y = Y * oonorm;
+	Z = Z * oonorm;
+	W = 1.0;
+	return 1 ;
+}
+
+ 
+inline int Vector3::Homogenize()
+{
+	if ( fabs( W ) < EpsAreas::eps_vanishdenominator  )
+		return 0 ;
+
+	double oow = 1 / W;
+	X = X * oow;
+	Y = Y * oow;
+	Z = Z * oow;
+	W = 1.0;
+	return 1 ;
+}
+
+ 
+inline int Vector3::IsNullVector() const
+{
+	 
+	return ( ( fabs( X ) < EpsAreas::eps_vanishcomponent  ) && ( fabs( Y ) < EpsAreas::eps_vanishcomponent  ) && ( fabs( Z ) < EpsAreas::eps_vanishcomponent  ) );
+}
+
+ 
+inline hprec_t Vector3::VecLength() const
+{
+	return sqrt( X * X + Y * Y + Z * Z );
+}
+
+ 
+inline hprec_t Vector3::DotProduct( const Vector3& vect ) const
+{
+	return ( vect.X * X ) + ( vect.Y * Y ) + ( vect.Z * Z );
+}
+
+ 
+inline void Vector3::CrossProduct( const Vector3& vect1, const Vector3& vect2 )
+{
+	X = ( vect1.Y * vect2.Z ) - ( vect1.Z * vect2.Y );
+	Y = ( vect1.Z * vect2.X ) - ( vect1.X * vect2.Z );
+	Z = ( vect1.X * vect2.Y ) - ( vect1.Y * vect2.X );
+	W = 1.0;
+}
+
+ 
+inline void Vector3::CreateDirVec( const Vertex3& vertex1, const Vertex3& vertex2 )
+{
+	X = vertex2.X - vertex1.X;
+	Y = vertex2.Y - vertex1.Y;
+	Z = vertex2.Z - vertex1.Z;
+	W = 1.0;
+}
+
+
+} 
+
+
+
+
+# 12 "../BspLib/Vector.h" 2
+
+# 1 "../BspLib/Vector2.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+# 1 "../BspLib/Vertex2.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+
+
+namespace BspLib  { 
+
+
+ 
+inline Vertex2::Vertex2( const Vector2& vect )
+{
+	X = vect.X;
+	Y = vect.Y;
+	W = vect.W;
+}
+
+ 
+inline int operator ==( const Vertex2 v1, const Vertex2 v2 )
+{
+	return ( ( v1.X == v2.X ) && ( v1.Y == v2.Y ) && ( v1.W == v2.W ) );
+}
+
+ 
+inline int operator !=( const Vertex2 v1, const Vertex2 v2 )
+{
+	return ( ( v1.X != v2.X ) || ( v1.Y != v2.Y ) || ( v1.W != v2.W ) );
+}
+
+ 
+inline Vertex2& Vertex2::operator +=( const Vector2 v )
+{
+	X += v.X;
+	Y += v.Y;
+
+	return *this;
+}
+
+ 
+inline Vertex2& Vertex2::operator -=( const Vector2 v )
+{
+	X -= v.X;
+	Y -= v.Y;
+
+	return *this;
+}
+
+ 
+inline int Vertex2::IsInVicinity( const Vertex2& vertex ) const
+{
+	return ( ( fabs( X - vertex.X ) < EpsAreas::eps_vertexmergearea  ) &&
+			 ( fabs( Y - vertex.Y ) < EpsAreas::eps_vertexmergearea  ) );
+}
+
+ 
+inline void Vertex2::InitFromVertex3( const Vertex3& vertex )
+{
+	X = vertex.getX();
+	Y = vertex.getY();
+	W = vertex.getZ();
+}
+
+
+} 
+
+
+
+
+# 13 "../BspLib/Vector2.h" 2
+
+
+
+namespace BspLib  { 
+
+
+ 
+inline Vector2 operator *( const Vector2 v1, double t )
+{
+	return Vector2( v1.X * t, v1.Y * t, 1.0 );
+}
+
+ 
+inline Vector2 operator *( double t, const Vector2 v1 )
+{
+	return Vector2( v1.X * t, v1.Y * t, 1.0 );
+}
+
+ 
+inline Vector2& Vector2::operator +=( const Vector2 v )
+{
+	X += v.X;
+	Y += v.Y;
+	return *this;
+}
+
+ 
+inline Vector2& Vector2::operator -=( const Vector2 v )
+{
+	X -= v.X;
+	Y -= v.Y;
+	return *this;
+}
+
+ 
+inline Vector2& Vector2::operator *=( double t )
+{
+	X *= t;
+	Y *= t;
+	return *this;
+}
+
+ 
+inline int Vector2::Normalize()
+{
+	if ( IsNullVector() )
+		return 0 ;
+
+	double oonorm = 1 / VecLength();
+	X = X * oonorm;
+	Y = Y * oonorm;
+	W = 1.0;
+	return 1 ;
+}
+
+ 
+inline int Vector2::Homogenize()
+{
+	if ( fabs( W ) < EpsAreas::eps_vanishdenominator  )
+		return 0 ;
+
+	double oow = 1 / W;
+	X = X * oow;
+	Y = Y * oow;
+	W = 1.0;
+	return 1 ;
+}
+
+ 
+inline int Vector2::IsNullVector() const
+{
+	 
+	return ( ( fabs( X ) < EpsAreas::eps_vanishcomponent  ) && ( fabs( Y ) < EpsAreas::eps_vanishcomponent  ) );
+}
+
+ 
+inline hprec_t Vector2::VecLength() const
+{
+	return sqrt( X * X + Y * Y );
+}
+
+ 
+inline hprec_t Vector2::DotProduct( const Vector2& vect ) const
+{
+	return ( vect.X * X ) + ( vect.Y * Y );
+}
+
+ 
+inline void Vector2::CreateDirVec( const Vertex2& vertex1, const Vertex2& vertex2 )
+{
+	X = vertex2.X - vertex1.X;
+	Y = vertex2.Y - vertex1.Y;
+	W = 1.0;
+}
+
+
+} 
+
+
+
+
+# 13 "../BspLib/Vector.h" 2
+
+
+
+namespace BspLib  { 
+
+
+ 
+inline Vertex3 operator +( const Vertex3 v1, const Vector3 v2 )
+{
+	return Vertex3( v1.X + v2.X, v1.Y + v2.Y, v1.Z + v2.Z, 1.0 );
+}
+
+ 
+inline Vertex3 operator +( const Vector3 v1, const Vertex3 v2 )
+{
+	return Vertex3( v1.X + v2.X, v1.Y + v2.Y, v1.Z + v2.Z, 1.0 );
+}
+
+ 
+inline Vector3 operator -( const Vertex3 v1, const Vertex3 v2 )
+{
+	return Vector3( v1.X - v2.X, v1.Y - v2.Y, v1.Z - v2.Z, 1.0 );
+}
+
+ 
+inline Vertex3 operator -( const Vertex3 v1, const Vector3 v2 )
+{
+	return Vertex3( v1.X - v2.X, v1.Y - v2.Y, v1.Z - v2.Z, 1.0 );
+}
+
+ 
+inline Vector3 operator +( const Vector3 v1, const Vector3 v2 )
+{
+	return Vector3( v1.X + v2.X, v1.Y + v2.Y, v1.Z + v2.Z, 1.0 );
+}
+
+ 
+inline Vector3 operator -( const Vector3 v1, const Vector3 v2 )
+{
+	return Vector3( v1.X - v2.X, v1.Y - v2.Y, v1.Z - v2.Z, 1.0 );
+}
+
+
+ 
+
+
+ 
+inline Vertex2 operator +( const Vertex2 v1, const Vector2 v2 )
+{
+	return Vertex2( v1.X + v2.X, v1.Y + v2.Y, 1.0 );
+}
+
+ 
+inline Vertex2 operator +( const Vector2 v1, const Vertex2 v2 )
+{
+	return Vertex2( v1.X + v2.X, v1.Y + v2.Y, 1.0 );
+}
+
+ 
+inline Vector2 operator -( const Vertex2 v1, const Vertex2 v2 )
+{
+	return Vector2( v1.X - v2.X, v1.Y - v2.Y, 1.0 );
+}
+
+ 
+inline Vertex2 operator -( const Vertex2 v1, const Vector2 v2 )
+{
+	return Vertex2( v1.X - v2.X, v1.Y - v2.Y, 1.0 );
+}
+
+ 
+inline Vector2 operator +( const Vector2 v1, const Vector2 v2 )
+{
+	return Vector2( v1.X + v2.X, v1.Y + v2.Y, 1.0 );
+}
+
+ 
+inline Vector2 operator -( const Vector2 v1, const Vector2 v2 )
+{
+	return Vector2( v1.X - v2.X, v1.Y - v2.Y, 1.0 );
+}
+
+
+} 
+
+
+
+
+# 199 "../BspLib/Vertex.h" 2
+
+# 1 "../BspLib/LineSeg2.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+
+
+
+namespace BspLib  { 
+
+
+ 
+ 
+class LineSeg2 {
+
+public:
+	LineSeg2( const Vertex2& basevtx, const Vector2& dirvec );
+	~LineSeg2() { }
+
+	int PointOnLineSeg( const Vertex2& vertex ) const;
+
+private:
+	Vertex2	m_basevtx;
+	Vector2 m_dirvec;
+};
+
+ 
+inline LineSeg2::LineSeg2( const Vertex2& basevtx, const Vector2& dirvec )
+{
+	m_basevtx = basevtx;
+	m_dirvec  = dirvec;
+}
+
+
+} 
+
+
+
+
+# 200 "../BspLib/Vertex.h" 2
+
+# 1 "../BspLib/LineSeg3.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+
+
+
+namespace BspLib  { 
+
+
+ 
+ 
+class LineSeg3 {
+
+public:
+	LineSeg3( const Vertex3& basevtx, const Vector3& dirvec );
+	~LineSeg3() { }
+
+	int PointOnLineSeg( const Vertex3& vertex ) const;
+
+private:
+	Vertex3	m_basevtx;
+	Vector3 m_dirvec;
+};
+
+ 
+inline LineSeg3::LineSeg3( const Vertex3& basevtx, const Vector3& dirvec )
+{
+	m_basevtx = basevtx;
+	m_dirvec  = dirvec;
+}
+
+
+} 
+
+
+
+
+# 201 "../BspLib/Vertex.h" 2
+
+# 1 "../BspLib/VertexChunk.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+
+
+
+namespace BspLib  { 
+
+
+ 
+ 
+class VertexChunkRep : public virtual SystemIO {
+
+	friend class VertexChunk;
+
+private:
+	VertexChunkRep( int chunksize = 0 );
+	~VertexChunkRep();
+
+	Vertex3&		FetchVertex( int index );
+	int				AddVertex( Vertex3 vertex );
+	int				FindVertex( const Vertex3& vertex );
+	int				FindCloseVertex( const Vertex3& vertex, int skip = -1 );
+	int				CheckVertices( int verbose );
+
+	int				getNumElements() const;
+
+private:
+	void			ChangeAxis( char xchar, hprec_t src );
+	int				VerticesEqual( Vertex3 v1, Vertex3 v2 );
+
+private:
+	int				ref_count;
+
+	int				numvertices;
+	int				maxnumvertices;
+	Vertex3*		vertices;
+	VertexChunkRep*	next;
+
+	int				nummultvertices;
+	static int		eliminatedoublets;
+	static const int CHUNK_SIZE;
+};
+
+ 
+inline VertexChunkRep::VertexChunkRep( int chunksize ) : ref_count( 0 )
+{
+	int challocsize	= chunksize > 0 ? chunksize : CHUNK_SIZE;
+	vertices		= new Vertex3[ challocsize ];
+	maxnumvertices	= challocsize;
+	numvertices		= 0;
+	next			= 0 ;
+}
+
+ 
+inline VertexChunkRep::~VertexChunkRep()
+{
+	delete next;
+	delete[] vertices;
+}
+
+ 
+inline int VertexChunkRep::VerticesEqual( Vertex3 v1, Vertex3 v2 )
+{
+ 
+	return ( v1 == v2 );
+}
+
+
+ 
+ 
+class VertexChunk {
+
+public:
+	VertexChunk( int chunksize = 0 ) { rep = new VertexChunkRep( chunksize ); rep->ref_count = 1; }
+	~VertexChunk() { if ( --rep->ref_count == 0 ) delete rep; }
+
+	VertexChunk( const VertexChunk& copyobj );
+	VertexChunk& operator =( const VertexChunk& copyobj );
+
+	Vertex3& operator []( int index ) { return rep->FetchVertex( index ); }
+	Vertex3& FetchVertex( int index ) { return rep->FetchVertex( index ); }
+
+	int	AddVertex( const Vertex3 vertex ) { return rep->AddVertex( vertex ); }
+	int	FindVertex( const Vertex3& vertex ) { return rep->FindVertex( vertex ); }
+	int	FindCloseVertex( Vertex3 vertex, int skip = -1 ) { return rep->FindCloseVertex( vertex, skip ); }
+	int	CheckVertices( int verbose ) { return rep->CheckVertices( verbose ); }
+
+	int	getNumElements() const { return rep->getNumElements(); }
+
+private:
+	VertexChunkRep*	rep;
+};
+
+ 
+inline VertexChunk::VertexChunk( const VertexChunk& copyobj )
+{
+	rep = copyobj.rep;
+	rep->ref_count++;
+}
+
+ 
+inline VertexChunk& VertexChunk::operator =( const VertexChunk& copyobj )
+{
+	if ( &copyobj != this ) {
+		if ( --rep->ref_count == 0 ) {
+			delete rep;
+		}
+		rep = copyobj.rep;
+		rep->ref_count++;
+	}
+	return *this;
+}
+
+
+} 
+
+
+
+
+# 202 "../BspLib/Vertex.h" 2
+
+
+
+
+
+# 13 "../BspLib/Plane.h" 2
+
+
+
+namespace BspLib  { 
+
+
+ 
+ 
+class Plane {
+
+	enum {
+		NORMAL_VALID	= 0x0001,
+		OFFSET_VALID	= 0x0002,
+		PLANE_VALID		= NORMAL_VALID | OFFSET_VALID,
+	};
+
+public:
+	Plane() : m_valid( 0 ) { }
+	Plane( const Vector3& pnormal );
+	Plane( const Vector3& pnormal, double poffset );
+	Plane( const Vertex3& v1, const Vertex3& v2, const Vertex3& v3 );
+	~Plane() { }
+
+	int			InitPlane( const Vertex3& v1, const Vertex3& v2, const Vertex3& v3 );
+	int			CalcPlaneOffset( const Vertex3& vtx );
+
+	Vector3		getPlaneNormal() const { return m_normal; }
+	void		setPlaneNormal( const Vector3& pnormal ) { m_normal = pnormal; }
+
+	double		getPlaneOffset() const { return m_offset; }
+	void		setPlaneOffset( double poffset ) { m_offset = poffset; }
+
+	int			NormalValid() const { return ( ( m_valid & NORMAL_VALID ) == NORMAL_VALID ); }
+	int			PlaneValid() const { return ( ( m_valid & PLANE_VALID ) == PLANE_VALID ); }
+
+	void		ApplyScaleFactor( double sfac );
+	void		EliminateDirectionality();
+
+	int			PointContained( const Vertex3& point ) const;
+	int			PointInPositiveHalfspace( const Vertex3& point ) const;
+	int			PointInNegativeHalfspace( const Vertex3& point ) const;
+
+private:
+	Vector3		m_normal;	 
+	double		m_offset;	 
+	int			m_valid;	 
+};
+
+ 
+inline Plane::Plane( const Vector3& pnormal )
+{
+	m_normal = pnormal;
+	m_offset = 0.0;
+	m_valid  = NORMAL_VALID;
+}
+
+ 
+inline Plane::Plane( const Vector3& pnormal, double poffset )
+{
+	m_normal = pnormal;
+	m_offset = poffset;
+	m_valid	 = PLANE_VALID;
+}
+
+ 
+inline Plane::Plane( const Vertex3& v1, const Vertex3& v2, const Vertex3& v3 )
+{
+	 
+	 
+	m_normal.CrossProduct( v3 - v1, v2 - v1 );
+
+	 
+	m_valid = m_normal.Normalize() ? PLANE_VALID : 0;
+
+	 
+	m_offset = m_normal.DotProduct( v1 );
+}
+
+ 
+inline int Plane::InitPlane( const Vertex3& v1, const Vertex3& v2, const Vertex3& v3 )
+{
+	*this = Plane( v1, v2, v3 );
+	return m_valid;
+}
+
+ 
+inline int Plane::CalcPlaneOffset( const Vertex3& vtx )
+{
+	 
+	m_offset = m_normal.DotProduct( vtx );
+	return ( m_valid |= OFFSET_VALID );
+}
+
+ 
+inline void Plane::ApplyScaleFactor( double sfac )
+{
+	 
+	 
+	m_offset *= sfac;
+}
+
+ 
+inline void Plane::EliminateDirectionality()
+{
+	if ( m_offset < 0.0 ) {
+		m_normal *= -1.0;
+		m_offset  = -m_offset;
+	}
+}
+
+ 
+inline int Plane::PointContained( const Vertex3& point ) const
+{
+	return ( fabs( m_normal.DotProduct( point ) - m_offset ) < EpsAreas::eps_planethickness  );
+}
+
+ 
+inline int Plane::PointInPositiveHalfspace( const Vertex3& point ) const
+{
+	return ( m_normal.DotProduct( point ) - m_offset >= EpsAreas::eps_planethickness  );
+}
+
+ 
+inline int Plane::PointInNegativeHalfspace( const Vertex3& point ) const
+{
+	return ( m_normal.DotProduct( point ) - m_offset <= - EpsAreas::eps_planethickness  );
+}
+
+
+} 
+
+
+
+
+# 15 "../BspLib/Face.h" 2
+
+
+# 1 "../BspLib/Texture.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+
+
+
+
+namespace BspLib  { 
+
+
+
+
+
+ 
+ 
+class Texture : public virtual SystemIO {
+
+public:
+	Texture( int w = -1, int h = -1, char *tname = 0 , char *fname = 0  );
+	~Texture() { }
+
+	int			getWidth() const { return m_width; }
+	int			getHeight() const { return m_height; }
+	const char*	getName() const { return m_name; }
+	const char*	getFile() const { return m_file; }
+
+	void		setWidth( int w ) { m_width = w; }
+	void		setHeight( int h ) { m_height = h; }
+	void		setName( const char *tname );
+	void		setFile( const char *fname );
+
+	void		WriteInfo( FILE *fp );
+
+private:
+	int			m_width;
+	int			m_height;
+	char		m_name[ 31  + 1 ];
+	char		m_file[ 1024  + 1 ];
+};
+
+ 
+typedef Chunk<Texture> TextureChunk;
+
+
+} 
+
+
+
+
+# 17 "../BspLib/Face.h" 2
+
+# 1 "../BspLib/TriMapping.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+
+
+
+
+namespace BspLib  { 
+
+
+ 
+ 
+class TriMapping : public virtual SystemIO {
+
+	void		Error() const;
+
+public:
+	TriMapping() { }
+	~TriMapping() { }
+
+	Vertex2&	getMapXY( int indx ) { if ( indx > 2 ) Error(); return map_xy[ indx ]; }
+	Vertex2&	getMapUV( int indx ) { if ( indx > 2 ) Error(); return map_uv[ indx ]; }
+
+private:
+	Vertex2		map_xy[ 3 ];	 
+	Vertex2		map_uv[ 3 ];	 
+};
+
+
+} 
+
+
+
+
+# 18 "../BspLib/Face.h" 2
+
+
+
+
+namespace BspLib  { 
+
+
+ 
+ 
+class Face : public virtual SystemIO {
+
+	void	Error() const;
+
+public:
+
+	 
+	enum ShadingType {
+		no_shad			= 0x1000,	 
+		flat_shad		= 0x1001,	 
+		gouraud_shad	= 0x1002,	 
+		afftex_shad		= 0x2003,	 
+		ipol1tex_shad	= 0x2004,	 
+		ipol2tex_shad	= 0x2005,	 
+		persptex_shad	= 0x2006,	 
+		material_shad	= 0x1007,	 
+		texmat_shad		= 0x3008,	 
+		num_shading_types = 9,		 
+		base_mask		= 0x00ff,	 
+		color_mask		= 0x1000,	 
+		texmap_mask		= 0x2000,	 
+	};
+
+	 
+	enum ColorModel {
+		no_col,					 
+		indexed_col,			 
+		rgb_col,				 
+		material_col,			 
+		num_color_models
+	};
+
+public:
+	Face();
+	~Face() { delete faceplane; delete facematerial; delete facemapping; delete texturename; }
+
+	Face( const Face& copyobj );
+	Face& operator =( const Face& copyobj );
+
+	int			getId() const { return faceid; }
+	void		setId( int id ) { faceid = id; }
+
+	Material	getMaterial() const { if ( facematerial == 0  ) Error(); return *facematerial; }
+	Plane		getPlane() const { if ( faceplane == 0  ) Error(); return *faceplane; }
+
+	Vector3		getPlaneNormal() const;
+	void		setPlaneNormal( const Vector3& normal );
+
+	int			getShadingType() const { return shadingtype; }
+	void		setShadingType( int type );
+
+	int			getColorType() const { return colortype; }
+	void		getColorIndex( dword& col ) const { col = facecolor_indx; }
+	void		getColorRGBA( ColorRGBA& col ) const { col = facecolor_rgba; }
+	void		getColorChannels( float& r, float& g, float& b ) const;
+	const char *getTextureName() { return texturename; }
+
+	void		setFaceColor( dword col );
+	void		setFaceColor( ColorRGBA col );
+	void		setTextureName( const char *tname );
+
+	int			NormalValid() const { return faceplane ? faceplane->NormalValid() : 0 ; }
+	int			PlaneValid() const { return faceplane ? faceplane->PlaneValid() : 0 ; }
+	int			MaterialAttached() const { return ( facematerial != 0  ); }
+	int			MappingAttached() const { return ( facemapping != 0  ); }
+	int			FaceTexMapped() const { return ( ( shadingtype & texmap_mask ) != 0 ); }
+
+	void		CalcPlane( const Vertex3& vertex1, const Vertex3& vertex2, const Vertex3& vertex3 );
+	void		AttachNormal( const Vector3& normal );
+	void		AttachPlane( Plane *plane );
+	void		AttachMaterial( Material *mat );
+
+	int			ConvertColorIndexToRGB( char *palette, int changemode );
+
+	Vertex2&	MapXY( int indx );
+	Vertex2&	MapUV( int indx );
+
+	void		WriteFaceInfo( FILE *fp ) const;
+	void		WriteNormalInfo( FILE *fp ) const;
+	void		WriteMappingInfo( FILE *fp ) const;
+
+public:
+	static int	GetTypeIndex( const char *type );
+	static int	GetColorModelIndex( const char *type );
+
+public:
+	static const char*	material_strings[];	 
+
+private:
+	static const char*	prop_strings[];		 
+	static const int	prop_ids[];			 
+	static const char*	color_strings[];	 
+	static const int	color_ids[];		 
+
+private:
+	int			faceid;			 
+	Plane*		faceplane;		 
+
+	int			shadingtype;	 
+	int			colortype;		 
+
+	dword		facecolor_indx;	 
+	ColorRGBA	facecolor_rgba;	 
+	Material*	facematerial;	 
+	TriMapping*	facemapping;	 
+	char*		texturename;	 
+};
+
+ 
+typedef Chunk<Face> FaceChunk;
+
+ 
+inline Face::Face()
+{
+	faceid		 = -1;		 
+	shadingtype  = -1;		 
+	colortype	 = -1;		 
+	faceplane	 = 0 ;	 
+	facematerial = 0 ;	 
+	facemapping	 = 0 ;	 
+	texturename	 = 0 ;	 
+}
+
+ 
+inline Vector3 Face::getPlaneNormal() const
+{
+	 
+		if ( ( faceplane == 0  ) || !faceplane->NormalValid() )
+			Error();
+	  ;
+	return faceplane->getPlaneNormal();
+}
+
+ 
+inline void Face::setPlaneNormal( const Vector3& normal )
+{
+	 
+		if ( ( faceplane == 0  ) || !faceplane->NormalValid() )
+			Error();
+	  ;
+	faceplane->setPlaneNormal( normal );
+}
+
+ 
+inline void Face::setShadingType( int type )
+{
+	 
+		if ( ( type & base_mask ) >= num_shading_types )
+			Error();
+	  ;
+	shadingtype = type;
+}
+
+ 
+inline void Face::setFaceColor( dword col )
+{
+	facecolor_indx	= col;
+	colortype		= indexed_col;
+}
+
+ 
+inline void Face::setFaceColor( ColorRGBA col )
+{
+	facecolor_rgba	= col;
+	colortype		= rgb_col;
+}
+
+ 
+inline void Face::getColorChannels( float& r, float& g, float& b ) const
+{
+	r = facecolor_rgba.R / 255.0f;
+	g = facecolor_rgba.G / 255.0f;
+	b = facecolor_rgba.B / 255.0f;
+}
+
+ 
+inline Vertex2& Face::MapXY( int indx )
+{
+	if ( facemapping == 0  )
+		facemapping = new TriMapping;
+	return facemapping->getMapXY( indx );
+}
+
+ 
+inline Vertex2& Face::MapUV( int indx )
+{
+	if ( facemapping == 0  )
+		facemapping = new TriMapping;
+	return facemapping->getMapUV( indx );
+}
+
+
+} 
+
+
+
+
+# 15 "../BspLib/BspObject.h" 2
+
+# 1 "../BspLib/Mapping.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+
+
+
+
+
+namespace BspLib  { 
+
+
+
+
+
+ 
+ 
+class Mapping : public virtual SystemIO {
+
+	void		Error( int vertindx );
+
+public:
+	Mapping() { numvertexindxs = 0; }
+	~Mapping() { }
+
+	void		InsertFaceVertex( int vindx ) { facevertexindxs[ numvertexindxs++ ] = vindx; }
+	void		SetCorrespondence( int vindx, Vertex2 vertex );
+	Vertex2		FetchMapPoint( int vertindx );
+
+	int			getNumVertices() { return numvertexindxs; }
+	void		setNumVertices( int num ) { numvertexindxs = num; }
+	void		setMappingCoordinates( int k, const Vertex2& vertex);
+
+	void		WriteMappingInfo( FILE *fp ) const;
+
+private:
+	int			numvertexindxs;
+	int			facevertexindxs[ 32  ];
+	Vertex2		mappingcoordinates[ 32  ];
+};
+
+ 
+typedef Chunk<Mapping> MappingChunk;
+
+ 
+inline void Mapping::setMappingCoordinates( int k, const Vertex2& vertex)
+{
+	if ( k < 32  )
+		mappingcoordinates[ k ] = vertex;
+	else
+		Error( k );
+}
+
+ 
+inline void Mapping::SetCorrespondence( int vindx, Vertex2 vertex )
+{
+	if ( numvertexindxs < 32  ) {
+		facevertexindxs[ numvertexindxs ] = vindx;
+		mappingcoordinates[ numvertexindxs ] = vertex;
+		numvertexindxs++;
+	} else {
+		Error( numvertexindxs );
+	}
+}
+
+ 
+inline Vertex2 Mapping::FetchMapPoint( int vertindx )
+{
+	for ( int i = 0; i < numvertexindxs; i++ )
+		if ( facevertexindxs[ i ] == vertindx )
+			return mappingcoordinates[ i ];
+	Error( vertindx );
+	return Vertex2( 0, 0 );	 
+}
+
+
+} 
+
+
+
+
+# 16 "../BspLib/BspObject.h" 2
+
+# 1 "../BspLib/PolygonList.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+# 1 "../BspLib/Polygon.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+
+
+
+
+
+
+namespace BspLib  { 
+
+
+class BoundingBox;
+
+
+ 
+ 
+class VIndx {
+
+public:
+	VIndx( int indx = -1, VIndx *next = 0  ) { vertindx = indx; nextvertindx = next; }
+	~VIndx() { delete nextvertindx; }
+
+	int		getIndx() const { return vertindx; }
+	void	setIndx( int indx ) { vertindx = indx; }
+
+	VIndx*	getNext() const { return nextvertindx; }
+	void	setNext( VIndx *next ) { nextvertindx = next; }
+
+private:
+	int		vertindx;			 
+	VIndx*	nextvertindx;		 
+};
+
+
+class BSPNode;
+class BspObject;
+
+
+ 
+ 
+class Polygon : public virtual SystemIO {
+
+	friend class PolygonListRep;
+
+	void	Error() const;
+
+	 
+	enum {
+		POLY_IN_FRONT_SUBSPACE,
+		POLY_IN_BACK_SUBSPACE,
+		POLY_STRADDLES_SPLITTER,
+		POLY_IN_SAME_PLANE,
+	};
+
+	 
+	enum {
+		FRONT_SUBSPACE	= 1,
+		BACK_SUBSPACE	= -1
+	};
+
+public:
+
+	 
+	enum {
+		SPLITTERCRIT_FIRST_POLY		= 0x0000,	 
+		SPLITTERCRIT_SAMPLE_FIRST_N	= 0x0101,	 
+		SPLITTERCRIT_SAMPLE_ALL		= 0x0002,	 
+		SPLITTERCRIT_RANDOM_SAMPLE	= 0x0103,	 
+		SPLITTERCRITMASK_SAMPLESIZ	= 0x0100,	 
+	};
+
+	 
+	enum {
+		MESSAGE_SPLITTING_POLYGON				= 0x0001,
+		MESSAGE_STARTVERTEX_IN_SPLITTER_PLANE	= 0x0002,
+		MESSAGE_VERTEX_IN_SPLITTER_PLANE		= 0x0004,
+		MESSAGE_NEW_SPLITVERTEX					= 0x0008,
+		MESSAGE_REUSING_SPLITVERTEX				= 0x0010,
+		MESSAGE_TRACEVERTEX_INSERTED			= 0x0020,
+		MESSAGE_SPLITTING_QUADRILATERAL			= 0x0040,
+		MESSAGE_INVOCATION						= 0x0080,
+		MESSAGE_CHECKING_POLYGON_PLANES			= 0x0100,
+		MESSAGEMASK_DISPLAY_ALL					= 0xffff
+	};
+
+public:
+	Polygon( BspObject *bobj, int pno = 0, int fno = 0, Polygon *next = 0 , int num = 1 );
+	~Polygon() { delete vertindxs; delete nextpolygon; }
+
+	Polygon*	NewPolygon();						 
+	Polygon*	InsertPolygon( Polygon *poly );		 
+	Polygon*	DeleteHead();						 
+	Polygon*	FindPolygon( int id );				 
+	int			SumVertexNumsEntireList();			 
+
+	void		PrependNewVIndx( int indx );		 
+	void		AppendNewVIndx( int indx = -1 );	 
+	void		AppendVIndx( VIndx *vindx );		 
+	VIndx*		UnlinkLastVIndx();					 
+
+	void		CalcPlaneNormals();					 
+	void		CheckEdges();						 
+	Polygon*	CheckPlanesAndMappings();			 
+
+	 
+	void		CalcBoundingBox( BoundingBox* &boundingbox );
+
+	 
+	int			CheckIntersection( Polygon *testpoly );
+	 
+	int			NormalDirectionSimilar( Polygon *testpoly );
+	 
+	void		SplitPolygon( Polygon *poly, Polygon* &frontsubspace, Polygon* &backsubspace );
+	 
+	BSPNode*	PartitionSpace();
+
+	 
+	void		CorrectBase( BspObject *newbaseobj, int vertexindxbase, int faceidbase, int polygonidbase );
+	void		CorrectBaseByTable( BspObject *newbaseobj, int *vtxindxmap, int faceidbase, int polygonidbase );
+
+	int			getId() const { return polygonno; }
+	void		setId( int pno ) { polygonno = pno; }
+
+	int			getFaceId() const { return faceno; }
+	void		setFaceId( int fno ) { faceno = fno; }
+
+	int			getNumPolygons() const { return numpolygons; }
+	void		setNumPolygons( int len ) { numpolygons = len; }
+
+	Polygon*	getNext() const { return nextpolygon; }
+	void		setNext( Polygon *next ) { nextpolygon = next; }
+
+	int			getNumVertices() const { return numvertindxs; }
+
+	VIndx*		getVList() const { return vertindxs; }
+	BspObject*	getBaseObject() const { return baseobject; }
+
+	VertexChunk& getVertexList();
+	FaceChunk&	getFaceList();
+
+	int			HasArea() const;
+
+	int			getFirstVertexIndx() const;
+	int			getSecondVertexIndx() const;
+	int			getThirdVertexIndx() const;
+
+	Vertex3		getFirstVertex() const;
+	Vertex3		getSecondVertex() const;
+	Vertex3		getThirdVertex() const;
+
+	Plane		getPlane() const { return ((Polygon *const)this)->getFaceList()[ faceno ].getPlane(); }
+	Vector3		getPlaneNormal() const { return ((Polygon *const)this)->getFaceList()[ faceno ].getPlaneNormal(); }
+
+	void		FillVertexIndexArray( dword *arr ) const;		 
+	void		WriteVertexList( FILE *fp, int cr ) const;		 
+	void		WritePolyList( FILE *fp ) const;				 
+
+	int			CalcSplitterTestProbability();
+
+public:
+	static int	getSplitterSelection() { return splitter_crit; }
+	static void	setSplitterSelection( int criterion ) { splitter_crit = criterion; }
+
+	static int	getSampleSize() { return sample_size; }
+	static void	setSampleSize( int siz ) { sample_size = siz; }
+
+	static int	getTriangulationFlag() { return triangulate_all; }
+	static void setTriangulationFlag( int flag ) { triangulate_all = flag; }
+
+	static int	getNormalizeVectorsFlag() { return normalize_vectors; }
+	static void setNormalizeVectorsFlag( int flag ) { normalize_vectors = flag; }
+
+	static int	getDisplayMessagesFlag() { return display_messages; }
+	static void setDisplayMessagesFlag( int flag ) { display_messages = flag; }
+
+	static void	ResetCallCount() { partition_callcount = 0; }
+
+private:
+	static int	splitter_crit;		 
+	static int	sample_size;		 
+	static int	triangulate_all;	 
+	static int	normalize_vectors;	 
+	static int	display_messages;	 
+	static int	partition_callcount; 
+	static int	test_probability;	 
+	static char	str_scratchpad[];	 
+
+private:
+	int			polygonno;			 
+	int			faceno;				 
+	int			numpolygons;		 
+	int			numvertindxs;		 
+	VIndx*		vertindxs;			 
+	VIndx*		vindxinsertpos;		 
+	BspObject*	baseobject;			 
+	Polygon*	nextpolygon;		 
+};
+
+ 
+inline int Polygon::HasArea() const
+{
+	 
+	 
+	return ( vertindxs && vertindxs->getNext() && vertindxs->getNext()->getNext() );
+}
+
+ 
+inline int Polygon::getFirstVertexIndx() const
+{
+	 
+		if ( vertindxs == 0  )
+			Error();
+	  ;
+	return vertindxs->getIndx();
+}
+inline Vertex3 Polygon::getFirstVertex() const
+{
+	 
+		if ( vertindxs == 0  )
+			Error();
+	  ;
+	return ((Polygon *const)this)->getVertexList()[ vertindxs->getIndx() ];
+}
+
+ 
+inline int Polygon::getSecondVertexIndx() const
+{
+	 
+		if ( ( vertindxs == 0  ) || ( vertindxs->getNext() == 0  ) )
+			Error();
+	  ;
+	return vertindxs->getNext()->getIndx();
+}
+inline Vertex3 Polygon::getSecondVertex() const
+{
+	 
+		if ( ( vertindxs == 0  ) || ( vertindxs->getNext() == 0  ) )
+			Error();
+	  ;
+	return ((Polygon *const)this)->getVertexList()[ vertindxs->getNext()->getIndx() ];
+}
+
+ 
+inline int Polygon::getThirdVertexIndx() const
+{
+	 
+		if ( ( vertindxs == 0  ) ||
+			 ( vertindxs->getNext() == 0  ) ||
+			 ( vertindxs->getNext()->getNext() == 0  ) )
+			Error();
+	  ;
+	return vertindxs->getNext()->getNext()->getIndx();
+}
+inline Vertex3 Polygon::getThirdVertex() const
+{
+	 
+		if ( ( vertindxs == 0  ) ||
+			 ( vertindxs->getNext() == 0  ) ||
+			 ( vertindxs->getNext()->getNext() == 0  ) )
+			Error();
+	  ;
+	return ((Polygon *const)this)->getVertexList()[ vertindxs->getNext()->getNext()->getIndx() ];
+}
+
+
+} 
+
+
+
+
+# 13 "../BspLib/PolygonList.h" 2
+
+
+
+
+namespace BspLib  { 
+
+
+class BSPNode;
+class BspObject;
+
+
+ 
+ 
+class PolygonListRep : public virtual SystemIO {
+
+	friend class PolygonList;
+
+	 
+	enum {
+		E_NEWVINDX,
+		E_APPENDVINDX,
+		E_GETNUMVERTXS
+	};
+
+	 
+	void		Error( int err ) const;
+
+private:
+	PolygonListRep( BspObject *bobj );
+	~PolygonListRep() { delete list; }
+
+	void		MergeLists( PolygonListRep *mergelist );
+
+	Polygon*	InitList( Polygon *listhead );
+
+	 
+	void		InvalidateList() { list = 0 ; numpolygons = 0; }
+
+	Polygon*	FetchHead() { return list; }
+	Polygon*	UnlinkHead();
+	Polygon*	DeleteHead();
+	Polygon*	FindPolygon( int id ) { return list ? list->FindPolygon( id ) : 0 ; }
+
+	Polygon*	NewPolygon();
+	Polygon*	InsertPolygon( Polygon *poly );
+
+	void		PrependNewVIndx( int indx = -1 ) { if ( list == 0  ) Error( E_NEWVINDX ); list->PrependNewVIndx( indx ); }
+	void		AppendNewVIndx( int indx = -1 ) { if ( list == 0  ) Error( E_NEWVINDX ); list->AppendNewVIndx( indx ); }
+	void		AppendVIndx( VIndx *vindx ) { if ( list == 0  ) Error( E_APPENDVINDX ); list->AppendVIndx( vindx ); }
+	Polygon*	CalcPlaneNormals();
+	Polygon*	CheckPolygonPlanes();
+	BSPNode*	PartitionSpace();
+
+	void		WritePolyList( FILE *fp, int no ) const;
+
+	int			getNumElements() const { return numpolygons; }
+	int			getNumVertices() const { if( list == 0  ) Error( E_GETNUMVERTXS ); return list->getNumVertices(); }
+
+private:
+	int			ref_count;			 
+	int			numpolygons;		 
+	BspObject*	baseobject;			 
+	Polygon*	list;				 
+};
+
+ 
+inline PolygonListRep::PolygonListRep( BspObject *bobj ) : ref_count( 0 )
+{
+	baseobject	= bobj;
+	list		= 0 ;
+	numpolygons	= 0;
+}
+
+
+ 
+ 
+class PolygonList {
+
+public:
+	PolygonList( BspObject *bobj ) { rep = new PolygonListRep( bobj ); rep->ref_count = 1; }
+	~PolygonList() { if ( --rep->ref_count == 0 ) delete rep; }
+
+	PolygonList( const PolygonList& copyobj );
+	PolygonList& operator =( const PolygonList& copyobj );
+
+	void		MergeLists( PolygonList *mergelist ) { if ( mergelist ) rep->MergeLists( mergelist->rep ); }
+
+	Polygon*	InitList( Polygon *listhead ) { return rep->InitList( listhead ); }
+	void		InvalidateList() { rep->InvalidateList(); }
+
+	Polygon*	FetchHead() { return rep->FetchHead(); }
+	Polygon*	UnlinkHead() { return rep->UnlinkHead(); }
+	Polygon*	DeleteHead() { return rep->DeleteHead(); }
+	Polygon*	FindPolygon( int id ) { return rep->FindPolygon( id ); }
+
+	Polygon*	NewPolygon() { return rep->NewPolygon(); }
+	Polygon*	InsertPolygon( Polygon *poly ) { return rep->InsertPolygon( poly ); }
+
+	void		PrependNewVIndx( int indx = -1 ) { rep->PrependNewVIndx( indx ); }
+	void		AppendNewVIndx( int indx = -1 ) { rep->AppendNewVIndx( indx ); }
+	void		AppendVIndx( VIndx *vindx ) { rep->AppendVIndx( vindx ); }
+	Polygon*	CalcPlaneNormals() { return rep->CalcPlaneNormals(); }
+	Polygon*	CheckPolygonPlanes() { return rep->CheckPolygonPlanes(); }
+	BSPNode*	PartitionSpace() { return rep->PartitionSpace(); }
+
+	void		WritePolyList( FILE *fp, int no ) const { rep->WritePolyList( fp, no ); }
+
+	int			getNumElements() const { return rep->getNumElements(); }
+	int			getNumVertices() const { return rep->getNumVertices(); }
+
+private:
+	PolygonListRep*	rep;
+};
+
+ 
+inline PolygonList::PolygonList( const PolygonList& copyobj )
+{
+	rep = copyobj.rep;	 
+	rep->ref_count++;	 
+}
+
+ 
+inline PolygonList& PolygonList::operator =( const PolygonList& copyobj )
+{
+	if ( &copyobj != this ) {
+		 
+		if ( --rep->ref_count == 0 ) {
+			delete rep;
+		}
+		rep = copyobj.rep;	 
+		rep->ref_count++;	 
+	}
+	return *this;
+}
+
+
+} 
+
+
+
+
+# 17 "../BspLib/BspObject.h" 2
+
+# 1 "../BspLib/BSPTree.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+# 1 "../BspLib/BspNode.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+
+
+
+
+namespace BspLib  { 
+
+
+class BoundingBox;
+class BspObject;
+
+
+ 
+ 
+class BSPNode {
+
+public:
+
+	 
+	enum {
+		OUTPUT_OLD_STYLE,
+		OUTPUT_KEY_VALUE_STYLE
+	};
+
+public:
+	BSPNode( BSPNode *front = 0 , BSPNode *back = 0 ,
+			 Polygon *poly = 0 , Polygon *backpoly = 0 ,
+			 Plane *sep = 0 , BoundingBox *box = 0 , int num = -1 );
+	~BSPNode();
+
+public:
+	void		NumberBSPNodes( int& curno );
+	void		SumVertexNums( int& vtxnum );
+	void		CorrectPolygonBases( BspObject *newbaseobj, int vertexindxbase, int faceidbase, int polygonidbase );
+	void		CorrectPolygonBasesByTable( BspObject *newbaseobj, int *vtxindxmap, int faceidbase, int polygonidbase );
+	void		WriteBSPTree( FILE *fp );
+	void		CheckEdges();
+	void		FetchFacePolygons( int facno, PolygonList& facepolylist );
+	Polygon*	FetchBSPPolygon( int polyno );
+	void		CalcBoundingBoxes();
+	void		CalcSeparatorPlanes();
+
+	int			getNodeNumber() const { return nodenumber; }
+	Polygon*	getPolygon() { return polygon; }
+	Polygon*	getBackPolygon() { return backpolygon; }
+	BSPNode*	getFrontSubtree() const { return frontsubtree; }
+	BSPNode*	getBackSubtree() const { return backsubtree; }
+
+	Plane*		getSeparatorPlane() { return separatorplane; }
+	void		setSeparatorPlane( Plane *sep ) { separatorplane = sep; }
+
+	BoundingBox*getBoundingBox() { return boundingbox; }
+	void		setBoundingBox( BoundingBox *box ) { boundingbox = box; }
+
+private:
+	void		GrowBoundingBox( BSPNode *othernode );
+
+public:
+	static int	getOutputFormat() { return outputformat; }
+	static void	setOutputFormat( int format ) { outputformat = format; }
+
+private:
+	static int	outputformat;	 
+
+private:
+	int			nodenumber;		 
+	Polygon*	polygon;		 
+	Polygon*	backpolygon;	 
+	Plane*		separatorplane;	 
+	BoundingBox*boundingbox;	 
+	BSPNode*	frontsubtree;	 
+	BSPNode*	backsubtree;	 
+};
+
+
+ 
+ 
+class BSPNodeFlat {
+
+public:
+	BSPNodeFlat( int front = 0, int back = 0,
+				 Polygon *poly = 0 , int clist = 0, int blist = 0,
+				 Plane *sep = 0 , BoundingBox *box = 0 , int num = -1 );
+	~BSPNodeFlat() {   }
+
+public:
+	void		InitNode( int front, int back, Polygon *poly, int clist, int blist,
+						  Plane *sep = 0 , BoundingBox *box = 0 , int num = -1 );
+
+	void		ApplyScaleFactor( double sfac );
+
+	int			getNodeNumber() const { return nodenumber; }
+	Polygon*	getPolygon() { return polygon; }
+	int			getContainedList() const { return containedlistindx; }
+	int			getBackList() const { return backlistindx; }
+	int			getFrontSubTree() const { return frontsubtreeindx; }
+	int			getBackSubTree() const { return backsubtreeindx; }
+
+	Plane*		getSeparatorPlane() { return separatorplane; }
+	void		setSeparatorPlane( Plane *sep ) { separatorplane = sep; }
+
+	BoundingBox*getBoundingBox() { return boundingbox; }
+	void		setBoundingBox( BoundingBox *box ) { boundingbox = box; }
+
+private:
+	int			nodenumber;			 
+	Polygon*	polygon;			 
+	Plane*		separatorplane;		 
+	BoundingBox*boundingbox;		 
+	int			containedlistindx;	 
+	int			backlistindx;		 
+	int			frontsubtreeindx;	 
+	int			backsubtreeindx;	 
+};
+
+
+} 
+
+
+
+
+# 13 "../BspLib/BSPTree.h" 2
+
+
+
+namespace BspLib  { 
+
+
+ 
+ 
+class BSPTreeRep {
+
+	friend class BSPTree;
+
+private:
+	BSPTreeRep() : ref_count( 0 ) { root = 0 ; }
+	~BSPTreeRep() { delete root; }
+
+	BSPNode*	InitTree( BSPNode *rootnode );
+	BSPNode*	getRoot() { return root; }
+
+	void		InvalidateTree();
+
+	int			TreeEmpty() const { return ( root == 0  ); }
+
+private:
+	int			ref_count;
+	BSPNode*	root;
+};
+
+ 
+inline BSPNode *BSPTreeRep::InitTree( BSPNode *rootnode )
+{
+	delete root;
+	return ( root = rootnode );
+}
+
+ 
+inline void BSPTreeRep::InvalidateTree()
+{
+	root = 0 ;
+}
+
+
+ 
+ 
+class BSPTree {
+
+public:
+	BSPTree() {	rep = new BSPTreeRep; rep->ref_count = 1; }
+	~BSPTree() { if ( --rep->ref_count == 0 ) delete rep; }
+
+	BSPTree( const BSPTree& copyobj );
+	BSPTree& operator =( const BSPTree& copyobj );
+
+	 
+	BSPNode*	operator->() { return rep->getRoot(); }
+
+	BSPNode*	InitTree( BSPNode *rootnode ) { return rep->InitTree( rootnode ); }
+	BSPNode*	getRoot() { return rep->getRoot(); }
+
+	void		InvalidateTree() { rep->InvalidateTree(); }
+
+	int			TreeEmpty() const { return rep->TreeEmpty(); }
+
+private:
+	BSPTreeRep*	rep;
+};
+
+ 
+inline BSPTree::BSPTree( const BSPTree& copyobj )
+{
+	rep = copyobj.rep;
+	rep->ref_count++;
+}
+
+ 
+inline BSPTree& BSPTree::operator =( const BSPTree& copyobj )
+{
+	if ( &copyobj != this ) {
+		if ( --rep->ref_count == 0 ) {
+			delete rep;
+		}
+		rep = copyobj.rep;
+		rep->ref_count++;
+	}
+	return *this;
+}
+
+
+ 
+ 
+class BSPTreeFlatRep {
+
+	friend class BSPTreeFlat;
+
+private:
+	BSPTreeFlatRep() : ref_count( 0 ) { root = 0 ; numnodes = 0; nodestorage = 0; }
+	~BSPTreeFlatRep() { delete[] root; }
+
+	BSPNodeFlat*	AppendNode( int front, int back, Polygon *poly, int clist, int blist );
+	BSPNodeFlat*	FetchNodePerId( int id );
+	BSPNode*		BuildBSPTree( int nodenum );
+	BSPNodeFlat*	getRoot() { return root; }
+
+	int				TreeEmpty() const { return ( root == 0  ); }
+	int				getNumNodes() const { return numnodes; }
+
+	void			ApplyScaleFactor( double sfac );
+	void			DestroyTree() { delete[] root; root = 0 ; numnodes = 0; nodestorage = 0; }
+
+private:
+	int				ref_count;
+	int				numnodes;
+	int				nodestorage;
+	BSPNodeFlat*	root;
+};
+
+
+ 
+ 
+class BSPTreeFlat {
+
+public:
+	BSPTreeFlat() {	rep = new BSPTreeFlatRep; rep->ref_count = 1; }
+	~BSPTreeFlat() { if ( --rep->ref_count == 0 ) delete rep; }
+
+	BSPTreeFlat( const BSPTreeFlat& copyobj );
+	BSPTreeFlat& operator =( const BSPTreeFlat& copyobj );
+
+	BSPNodeFlat*	AppendNode( int front, int back, Polygon *poly, int clist, int blist )
+		{ return rep->AppendNode( front, back, poly, clist, blist ); }
+	BSPNodeFlat*	FetchNodePerId( int id ) { return rep->FetchNodePerId( id ); }
+	BSPNode*		BuildBSPTree( int nodenum ) { return rep->BuildBSPTree( nodenum ); }
+	BSPNodeFlat*	getRoot() { return rep->getRoot(); }
+
+	int				TreeEmpty() const { return rep->TreeEmpty(); }
+	int				getNumNodes() const { return rep->getNumNodes(); }
+
+	void			ApplyScaleFactor( double sfac ) { rep->ApplyScaleFactor( sfac ); }
+	void			DestroyTree() { rep->DestroyTree(); }
+
+private:
+	BSPTreeFlatRep*	rep;
+};
+
+ 
+inline BSPTreeFlat::BSPTreeFlat( const BSPTreeFlat& copyobj )
+{
+	rep = copyobj.rep;
+	rep->ref_count++;
+}
+
+ 
+inline BSPTreeFlat& BSPTreeFlat::operator =( const BSPTreeFlat& copyobj )
+{
+	if ( &copyobj != this ) {
+		if ( --rep->ref_count == 0 ) {
+			delete rep;
+		}
+		rep = copyobj.rep;
+		rep->ref_count++;
+	}
+	return *this;
+}
+
+
+} 
+
+
+
+
+# 18 "../BspLib/BspObject.h" 2
+
+
+# 1 "../BspLib/Transform3.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+
+
+
+namespace BspLib  { 
+
+
+ 
+ 
+class Transform3 {
+
+	friend Transform3 operator *( const Transform3& trafo1, const Transform3& trafo2 );
+
+public:
+	Transform3();
+	Transform3( const float trafo[4][4] );
+	Transform3( const double trafo[4][4] );
+	~Transform3() { }
+
+	 
+	Vector3		TransformVector3( const Vector3& vec ) const;
+
+	 
+	Transform3&	Concat( const Transform3& cattrafo );
+	Transform3&	ConcatR( const Transform3& cattrafo );
+
+	 
+	Transform3&	LoadIdentity();
+	Transform3&	LoadRotation( double angle, double x, double y, double z );
+	Transform3&	LoadScale( double x, double y, double z );
+	Transform3&	LoadTranslation( double x, double y, double z );
+
+	 
+	Transform3&	Rotate( double angle, double x, double y, double z );
+	Transform3&	Scale( double x, double y, double z );
+	Transform3&	Translate( double x, double y, double z );
+
+	 
+	Transform3&	RotateR( double angle, double x, double y, double z );
+	Transform3&	ScaleR( double x, double y, double z );
+	Transform3&	TranslateR( double x, double y, double z );
+
+	 
+	Vector3		FetchTranslation() const;
+	Vector3		ExtractTranslation();
+
+private:
+	 
+	double	m_matrix[4][4];
+};
+
+ 
+inline Transform3& Transform3::LoadIdentity()
+{
+	memset( m_matrix, 0, sizeof( m_matrix ) );
+
+	m_matrix[ 0 ][ 0 ] = 1.0;
+	m_matrix[ 1 ][ 1 ] = 1.0;
+	m_matrix[ 2 ][ 2 ] = 1.0;
+	m_matrix[ 3 ][ 3 ] = 1.0;
+
+	return *this;
+}
+
+ 
+inline Transform3::Transform3()
+{
+ 
+}
+
+ 
+inline Transform3::Transform3( const double trafo[4][4] )
+{
+	 
+	 
+	 
+	memcpy( m_matrix, trafo, sizeof( m_matrix ) );
+}
+
+ 
+inline Transform3::Transform3( const float trafo[4][4] )
+{
+	 
+	 
+	 
+	for ( int i = 0; i < 16; i++ )
+		((double *)m_matrix)[ i ] = (double) ((float *)trafo)[ i ];
+}
+
+
+} 
+
+
+
+
+# 20 "../BspLib/BspObject.h" 2
+
+
+
+
+namespace BspLib  { 
+
+
+class BoundingBox;
+
+
+ 
+ 
+class BspObjectInfo {
+
+	friend class BspObject;
+
+private:
+	BspObjectInfo();
+	~BspObjectInfo() { }
+
+public:
+	int	getNumVertices() const		{ return numvertices; }
+	int	getNumPolygons() const		{ return numpolygons; }
+	int	getNumFaces() const			{ return numfaces; }
+
+	int	getInputVertices() const	{ return numvertices_in; }
+	int	getInputPolygons() const	{ return numpolygons_in; }
+	int	getInputFaces() const		{ return numfaces_in; }
+
+	int getBspPolygons() const		{ return numbsppolygons; }
+	int getPreBspPolygons() const	{ return numpolygons_before_bsp; }
+
+	int	getNumTextures() const		{ return numtextures; }
+	int	getNumMappings() const		{ return numcorrespondences; }
+	int	getNumNormals() const		{ return numnormals; }
+	int	getNumTexturedFaces() const	{ return numtexmappedfaces; }
+
+	int getNumTraceVertices() const	{ return numtracevertices; }
+	int getNumMultiVertices() const	{ return nummultvertices; }
+	int getNumSplitQuads() const	{ return numsplitquadrilaterals; }
+
+protected:
+	int numvertices;				 
+	int numpolygons;				 
+	int numfaces;					 
+	int numtextures;				 
+	int numcorrespondences;			 
+
+	int numnormals;					 
+	int numtexmappedfaces;			 
+
+	int numvertices_in;				 
+	int numpolygons_in;				 
+	int numfaces_in;				 
+
+	int numbsppolygons;				 
+	int numpolygons_before_bsp;		 
+
+	int numtracevertices;			 
+	int nummultvertices;			 
+	int numsplitquadrilaterals;		 
+};
+
+
+ 
+ 
+class BspObject : public BspObjectInfo, public virtual SystemIO {
+
+	friend class BoundingBox;
+	friend class BspObjectListRep;
+	friend class Face;
+	friend class ObjectBSPNode;
+	friend class Polygon;
+
+	friend class VrmlFile;
+
+public:
+	BspObject();
+	~BspObject() { delete objectname; delete next; }
+
+	BspObject( const BspObject& copyobj );
+	BspObject& operator =( const BspObject& copyobj );
+
+	 
+	 
+	void			MergeObjects( BspObject *mergeobj );
+
+	void			CollapseObjectList();		 
+
+	BoundingBox*	BuildBoundingBoxList();		 
+
+	BSPNode*		BuildBSPTree();				 
+	BSPNode*		BuildBSPTreeFromFlat();		 
+
+	int				BspTreeAvailable();			 
+	int				BSPTreeAvailable();			 
+	int				BSPTreeFlatAvailable();		 
+
+	 
+	void			CalcBoundingBoxes();		 
+	void			CalcSeparatorPlanes();		 
+	void			CheckEdges();				 
+	void			CheckPolygonPlanes();		 
+	void			CheckVertices( int verbose );  
+	void			CalcPlaneNormals();			 
+	void			CheckParsedData();			 
+	void			UpdateAttributeNumbers();	 
+
+	int				ConvertColorIndexesToRGB( char *palette, int changemode );
+
+	 
+	void			CalcBoundingBox( Vertex3& minvertex, Vertex3& maxvertex );
+
+	 
+	void			DisplayStatistics();
+
+	 
+	 
+	 
+	virtual int		WriteVertexList( FileAccess& fp ) { return 0 ; }
+	virtual int		WritePolygonList( FileAccess& fp ) { return 0 ; }
+	virtual int		WriteFaceList( FileAccess& fp ) { return 0 ; }
+	virtual int		WriteFaceProperties( FileAccess& fp ) { return 0 ; }
+	virtual int		WriteTextureList( FileAccess& fp ) { return 0 ; }
+	virtual int		WriteMappingList( FileAccess& fp ) { return 0 ; }
+	virtual int		WriteNormals( FileAccess& fp ) { return 0 ; }
+	virtual int		WriteBSPTree( FileAccess& fp ) { return 0 ; }
+
+	 
+	VertexChunk&	getVertexList()		{ return vertexlist; }
+	PolygonList&	getPolygonList()	{ return polygonlist; }
+	FaceChunk&		getFaceList()		{ return facelist; }
+	TextureChunk&	getTextureList()	{ return texturelist; }
+	MappingChunk&	getMappingList()	{ return mappinglist; }
+	BSPTree&		getBSPTree()		{ return bsptree; }
+	BSPTreeFlat&	getBSPTreeFlat()	{ return bsptreeflat; }
+
+	 
+	char*			getObjectName()	const { return objectname; }
+	void			setObjectName( char *name );
+
+	 
+	Vertex3			getCenterInWorldSpace() const { return objecttrafo.FetchTranslation(); }
+	Transform3		getObjectTransformation() const { return objecttrafo; }
+	void			setObjectTransformation( const Transform3& ot ) { objecttrafo = ot; }
+
+	 
+	void			ApplyScale( double scalefac );
+
+	 
+	void			ApplyCenter();
+
+	 
+	void			ApplyTransformation();
+
+	 
+	BspObject*		getNext() const { return next; }
+
+private:
+	void			InconsistencyError( const char *err );
+
+public:
+	static int		getEliminateDoubletsOnMergeFlag() { return check_vertex_doublets_on_merge; }
+	static void		setEliminateDoubletsOnMergeFlag( int flag ) { check_vertex_doublets_on_merge = flag; }
+
+private:
+	static int		check_vertex_doublets_on_merge;
+
+protected:
+	 
+	VertexChunk		vertexlist;		 
+	PolygonList		polygonlist;	 
+	FaceChunk		facelist;		 
+	TextureChunk	texturelist;	 
+	MappingChunk	mappinglist;	 
+	BSPTree			bsptree;		 
+	BSPTreeFlat		bsptreeflat;	 
+	Transform3		objecttrafo;	 
+
+	 
+	char*			objectname;
+
+	 
+	BspObject*		next;
+};
+
+ 
+inline BspObject::BspObject( const BspObject& copyobj ) :
+	BspObjectInfo( copyobj ),
+	vertexlist( copyobj.vertexlist ),
+	polygonlist( copyobj.polygonlist ),
+	facelist( copyobj.facelist ),
+	texturelist( copyobj.texturelist ),
+	mappinglist( copyobj.mappinglist ),
+	bsptree( copyobj.bsptree ),
+	bsptreeflat( copyobj.bsptreeflat ),
+	objecttrafo( copyobj.objecttrafo )
+{
+	 
+	objectname = 0 ;
+	setObjectName( copyobj.objectname );
+
+	 
+	next = 0 ;
+}
+
+ 
+inline BspObject& BspObject::operator =( const BspObject& copyobj )
+{
+	if ( &copyobj != this ) {
+
+		 
+		*(BspObjectInfo *)this = copyobj;
+
+		 
+		vertexlist	= copyobj.vertexlist;
+		polygonlist	= copyobj.polygonlist;
+		facelist	= copyobj.facelist;
+		texturelist	= copyobj.texturelist;
+		mappinglist	= copyobj.mappinglist;
+		bsptree		= copyobj.bsptree;
+		bsptreeflat	= copyobj.bsptreeflat;
+		objecttrafo	= copyobj.objecttrafo;
+
+		 
+		setObjectName( copyobj.objectname );
+
+		 
+		next = 0 ;
+	}
+	return *this;
+}
+
+
+} 
+
+
+
+
+# 13 "../BspLib/BoundingBox.h" 2
+
+
+
+
+namespace BspLib  { 
+
+
+ 
+ 
+class BoundingBox {
+
+	friend class ObjectBSPNode;
+
+public:
+	BoundingBox() { containedobject = 0 ; nextbox = 0 ; }
+	BoundingBox( BspObject *cobj, BoundingBox *next = 0  );
+	BoundingBox( const Vertex3& minvert, const Vertex3& maxvert, BoundingBox *next = 0  );
+	~BoundingBox() { delete nextbox; }
+
+	void			ApplyScaleFactor( double sfac );
+	void			GrowBoundingBox( BoundingBox *otherbox );
+	void			BoundingBoxListUnion( BoundingBox& unionbox );
+	ObjectBSPNode*	PartitionSpace();
+
+	Vertex3			getMinVertex() const { return minvertex; }
+	Vertex3			getMaxVertex() const { return maxvertex; }
+	BspObject*		getContainedObject() const { return containedobject; }
+	BoundingBox*	getNext() const { return nextbox; }
+
+private:
+	Vertex3			minvertex;
+	Vertex3			maxvertex;
+	BspObject*		containedobject;
+	BoundingBox*	nextbox;
+};
+
+ 
+inline BoundingBox::BoundingBox( BspObject *cobj, BoundingBox *next )
+{
+	if ( ( containedobject = cobj ) != 0  ) {
+		cobj->CalcBoundingBox( minvertex, maxvertex );
+	}
+	nextbox = next;
+}
+
+ 
+inline BoundingBox::BoundingBox( const Vertex3& minvert, const Vertex3& maxvert, BoundingBox *next )
+{
+	minvertex		= minvert;
+	maxvertex		= maxvert;
+	containedobject	= 0 ;
+	nextbox			= next;
+}
+
+
+} 
+
+
+
+
+# 13 "../BspLib/VrmlFile.h" 2
+
+# 1 "../BspLib/InputData3D.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+# 1 "../BspLib/BspObjectList.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+
+# 1 "../BspLib/ObjectBSPTree.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+# 1 "../BspLib/ObjectBSPNode.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+
+
+
+
+
+namespace BspLib  { 
+
+
+ 
+ 
+class ObjectBSPNode {
+
+public:
+	ObjectBSPNode( ObjectBSPNode *front = 0 , ObjectBSPNode *back = 0 , Plane *sep = 0 , BoundingBox *bbox = 0 , int id = -1 );
+	~ObjectBSPNode() { delete separatorplane; delete boundingbox; delete frontsubtree; delete backsubtree; }
+
+	void			NumberBSPNodes( int& curno );
+	void			WriteBSPTree( FILE *fp ) const;
+
+	BspObject*		CreateObjectList();
+	BspObject*		CreateMergedBSPTree();
+
+	void			DeleteNodeBspObjects();
+
+	int				getNodeNumber() const { return nodenumber; }
+	Plane*			getSeparatorPlane() const { return separatorplane; }
+	BoundingBox*	getBoundingBox() const { return boundingbox; }
+	ObjectBSPNode*	getFrontSubtree() const { return frontsubtree; }
+	ObjectBSPNode*	getBackSubtree() const { return backsubtree; }
+
+private:
+	void			MergeTreeNodeObjects( BspObject *newobject );
+	BSPNode*		CreateUnifiedBSPTree();
+
+private:
+	int				nodenumber;		 
+	Plane*			separatorplane;	 
+	BoundingBox*	boundingbox;	 
+	ObjectBSPNode*	frontsubtree;	 
+	ObjectBSPNode*	backsubtree;	 
+};
+
+ 
+inline ObjectBSPNode::ObjectBSPNode( ObjectBSPNode *front, ObjectBSPNode *back, Plane *sep, BoundingBox *bbox, int id )
+{
+	frontsubtree	= front;
+	backsubtree		= back;
+	separatorplane	= sep;
+	boundingbox		= bbox;
+	nodenumber		= id;
+}
+
+
+} 
+
+
+
+
+# 13 "../BspLib/ObjectBSPTree.h" 2
+
+
+
+namespace BspLib  { 
+
+
+ 
+ 
+class ObjectBSPTreeRep {
+
+	friend class ObjectBSPTree;
+
+private:
+	ObjectBSPTreeRep() : ref_count( 0 ) { root = 0 ; }
+	~ObjectBSPTreeRep() { delete root; }
+
+	void			KillTree() { delete root; root = 0 ; }
+	ObjectBSPNode*	InitTree( ObjectBSPNode *rootnode );
+	ObjectBSPNode*	getRoot() { return root; }
+
+	int				TreeEmpty() const { return ( root == 0  ); }
+
+private:
+	int				ref_count;
+	ObjectBSPNode*	root;
+};
+
+ 
+inline ObjectBSPNode *ObjectBSPTreeRep::InitTree( ObjectBSPNode *rootnode )
+{
+	delete root;
+	return ( root = rootnode );
+}
+
+
+ 
+ 
+class ObjectBSPTree {
+
+public:
+	ObjectBSPTree() { rep = new ObjectBSPTreeRep; rep->ref_count = 1; }
+	~ObjectBSPTree() { if ( --rep->ref_count == 0 ) delete rep; }
+
+	ObjectBSPTree( const ObjectBSPTree& copyobj );
+	ObjectBSPTree& operator =( const ObjectBSPTree& copyobj );
+
+	 
+	ObjectBSPNode*	operator->() { return rep->getRoot(); }
+
+	void			KillTree() { rep->KillTree(); }
+	ObjectBSPNode*	InitTree( ObjectBSPNode *rootnode ) { return rep->InitTree( rootnode ); }
+	ObjectBSPNode*	getRoot() { return rep->getRoot(); }
+
+	int				TreeEmpty() const { return rep->TreeEmpty(); }
+
+private:
+	ObjectBSPTreeRep* rep;
+};
+
+ 
+inline ObjectBSPTree::ObjectBSPTree( const ObjectBSPTree& copyobj )
+{
+	rep = copyobj.rep;
+	rep->ref_count++;
+}
+
+ 
+inline ObjectBSPTree& ObjectBSPTree::operator =( const ObjectBSPTree& copyobj )
+{
+	if ( &copyobj != this ) {
+		if ( --rep->ref_count == 0 ) {
+			delete rep;
+		}
+		rep = copyobj.rep;
+		rep->ref_count++;
+	}
+	return *this;
+}
+
+
+} 
+
+
+
+
+# 14 "../BspLib/BspObjectList.h" 2
+
+
+
+namespace BspLib  { 
+
+
+ 
+ 
+class BspObjectListRep {
+
+	friend class BspObjectList;
+
+public:
+	BspObjectListRep() : ref_count( 0 ) { list = 0 ; }
+	~BspObjectListRep() { delete list; }
+
+	BspObject*		CreateNewObject();				 
+	BspObject*		InsertObject( BspObject *obj );	 
+
+	BoundingBox*	BuildBoundingBoxList();			 
+
+	int				CountListObjects();				 
+
+	int				PrepareObjectBSPTree( ObjectBSPTree& objbsptree );
+	int				MergeObjectBSPTree( ObjectBSPTree& objbsptree );
+
+	int				CollapseObjectList();			 
+
+	int				ProcessObjects( int flags );	 
+
+	int				BspTreeAvailable() { return list ? list->BspTreeAvailable() : 0 ; }
+	int				BSPTreeAvailable() { return list ? list->BSPTreeAvailable() : 0 ; }
+	int				BSPTreeFlatAvailable() { return list ? list->BSPTreeFlatAvailable() : 0 ; }
+
+	BspObject*		getListHead() const { return list; }
+
+private:
+	int				ref_count;	 
+	BspObject*		list;		 
+};
+
+
+ 
+ 
+class BspObjectList {
+
+public:
+
+	 
+	enum {
+		CHECK_PLANES			= 0x0001,
+		BUILD_BSP				= 0x0002,
+		CHECK_VERTICES			= 0x0004,
+		CHECK_EDGES				= 0x0008,
+		BUILD_BSP_WITH_CHECKS	= 0x000F,
+		DISPLAY_STATS			= 0x0010,
+		BUILD_FROM_FLAT			= 0x0020,
+		MERGE_VERTICES			= 0x0040,
+		CULL_NULL_EDGES			= 0x0080,
+		ELIMINATE_T_VERTICES	= 0x0100,
+		MERGE_FACES				= 0x0200,
+		CALC_PLANE_NORMALS		= 0x0400,
+		CALC_BOUNDING_BOXES		= 0x0800,
+		CALC_SEPARATOR_PLANES	= 0x1000,
+		APPLY_TRANSFORMATIONS	= 0x2000,
+	};
+
+public:
+	BspObjectList() { rep = new BspObjectListRep(); rep->ref_count = 1; }
+	~BspObjectList() { if ( --rep->ref_count == 0 ) delete rep; }
+
+	BspObjectList( const BspObjectList& copyobj );
+	BspObjectList& operator =( const BspObjectList& copyobj );
+
+	BspObject*		CreateNewObject() { return rep->CreateNewObject(); }
+	BspObject*		InsertObject( BspObject *obj ) { return rep->InsertObject( obj ); }
+
+	 
+	 
+	BoundingBox*	BuildBoundingBoxList() { return rep->BuildBoundingBoxList(); }
+
+	int				CountListObjects() { return rep->CountListObjects(); }
+
+	int				PrepareObjectBSPTree( ObjectBSPTree& objbsptree ) { return rep->PrepareObjectBSPTree( objbsptree ); }
+	int				MergeObjectBSPTree( ObjectBSPTree& objbsptree ) { return rep->MergeObjectBSPTree( objbsptree ); }
+
+	int				CollapseObjectList() { return rep->CollapseObjectList(); }
+
+	 
+	int				ProcessObjects( int flags ) { return rep->ProcessObjects( flags ); }
+
+	 
+	int				BspTreeAvailable() { return rep->BspTreeAvailable(); }
+	 
+	int				BSPTreeAvailable() { return rep->BSPTreeAvailable(); }
+	 
+	int				BSPTreeFlatAvailable() { return rep->BSPTreeFlatAvailable(); }
+
+	 
+	 
+	 
+	 
+	 
+
+	 
+	BspObject*		getListHead() { return rep->getListHead(); }
+
+private:
+	BspObjectListRep *rep;
+};
+
+ 
+inline BspObjectList::BspObjectList( const BspObjectList& copyobj )
+{
+	rep = copyobj.rep;	 
+	rep->ref_count++;	 
+}
+
+ 
+inline BspObjectList& BspObjectList::operator =( const BspObjectList& copyobj )
+{
+	if ( &copyobj != this ) {
+		 
+		if ( --rep->ref_count == 0 ) {
+			delete rep;
+		}
+		rep = copyobj.rep;	 
+		rep->ref_count++;	 
+	}
+	return *this;
+}
+
+
+} 
+
+
+
+
+# 13 "../BspLib/InputData3D.h" 2
+
+# 1 "../BspLib/IOData3D.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+
+
+
+
+namespace BspLib  { 
+
+
+ 
+ 
+class IOData3D : public virtual SystemIO {
+
+public:
+
+	 
+	enum {
+		DONT_CREATE_OBJECT	= 0x0000,	 
+		UNKNOWN_FORMAT		= 0x0001,	 
+		AOD_FORMAT_1_1		= 0x0002,	 
+		VRML_FORMAT_1_0		= 0x0003,	 
+		BSP_FORMAT_1_1		= 0x0004,	 
+		_3DX_FORMAT_1_0		= 0x0005,	 
+		 
+	};
+
+protected:
+
+	 
+	enum {
+		NO_CHECKS		= 0x0000,		 
+		CHECK_FILENAME	= 0x0001,		 
+		ALL_CHECKS		= 0x0001
+	};
+
+public:
+	IOData3D( BspObjectList objectlist, const String& filename, int checkflags = ALL_CHECKS );
+	~IOData3D() { }
+
+	BspObjectList	getObjectList() const { return m_objectlist; }
+	String			getFileName() const { return m_filename; }
+	void			setFileName( const String& filename ) { m_filename = filename; }
+
+protected:
+	BspObjectList	m_objectlist;	 
+	String			m_filename;		 
+
+protected:
+	 
+	static const char  AOD_SIGNATURE_1_1[];
+	static const char VRML_SIGNATURE_1_0[];
+	static const char  BSP_SIGNATURE_1_1[];
+	static const char _3DX_SIGNATURE_1_0[];
+	 
+
+	 
+	static const int TEXTLINE_MAX;
+	static char	line[];
+};
+
+
+} 
+
+
+
+
+# 14 "../BspLib/InputData3D.h" 2
+
+
+
+namespace BspLib  { 
+
+
+ 
+ 
+class InputData3D : public IOData3D {
+
+public:
+	 
+	enum {
+		CONVERT_COLINDXS_TO_RGB	= 0x0001,
+		FILTER_SCALE_FACTORS	= 0x0002,
+		FILTER_AXES_DIR_SWITCH	= 0x0004,
+		FILTER_AXES_EXCHANGE	= 0x0008,
+		DO_AXES_EXCHANGE		= FILTER_AXES_DIR_SWITCH | FILTER_AXES_EXCHANGE,
+		FORCE_MAXIMUM_EXTENT	= 0x0010,
+		ALLOW_N_GONS			= 0x0020,
+	};
+
+public:
+	InputData3D( BspObjectList objectlist, const char *filename, int format = UNKNOWN_FORMAT );
+	virtual ~InputData3D();
+
+	virtual int		ParseObjectData();									 
+
+	int				getObjectFormat() const { return m_objectformat; }	 
+	InputData3D*	getRealObject() const { return m_data; }			 
+
+	int				InputDataValid() const { return m_inputok; }		 
+
+	 
+	static int		EnableRGBConversion( int enable );
+	static int		EnableScaleFactors( int enable );
+	static int		EnableAxesChange( int enable );
+	static int		EnableMaximumExtent( int enable, double extent );
+	static int		EnableAllowNGons( int enable );
+
+	 
+	static int		getRGBConversionFlag() { return ( ( PostProcessingFlags & CONVERT_COLINDXS_TO_RGB ) == CONVERT_COLINDXS_TO_RGB ); }
+	static int		getScaleFactorsFlag() { return ( ( PostProcessingFlags & FILTER_SCALE_FACTORS ) == FILTER_SCALE_FACTORS ); }
+	static int		getAxesChangeFlag() { return ( ( PostProcessingFlags & DO_AXES_EXCHANGE ) == DO_AXES_EXCHANGE ); }
+	static int		getEnforceExtentsFlag() { return ( ( PostProcessingFlags & FORCE_MAXIMUM_EXTENT ) == FORCE_MAXIMUM_EXTENT ); }
+	static double	getMaxExtents() { return MaximumExtentToForce; }
+	static int		getAllowNGonFlag() { return ( ( PostProcessingFlags & ALLOW_N_GONS ) == ALLOW_N_GONS ); }
+
+private:
+	int				ReadFileSignature();
+
+protected:
+	static dword	PostProcessingFlags;
+	static double	MaximumExtentToForce;
+	static const char parser_err_str[];
+
+protected:
+	int				m_objectformat;
+	int				m_inputok;
+
+private:
+	InputData3D*	m_data;
+};
+
+
+} 
+
+
+
+
+# 14 "../BspLib/VrmlFile.h" 2
+
+
+
+namespace BspLib  { 
+
+
+class BspObjectList;
+
+ 
+ 
+class VrmlFile : public InputData3D {
+
+	friend class BRep;
+
+public:
+	VrmlFile( BspObjectList objectlist, const char *filename );
+	~VrmlFile();
+
+	int				ParseObjectData();
+	int				WriteOutputFile();
+
+private:
+	void			ApplySceneTransformations();
+	void			EnforceSceneExtents( BoundingBox& unionbox );
+
+private:
+	BoundingBox*	m_bboxlist;
+};
+
+
+} 
+
+
+
+
+# 7 "QvState.h" 2
+
+ 
+
+class QvState {
+
+  public:
+
+     
+    enum StackIndex {
+	CameraIndex,
+	Coordinate3Index,
+	LightIndex,
+	MaterialBindingIndex,
+	MaterialIndex,
+	NormalBindingIndex,
+	NormalIndex,
+	ShapeHintsIndex,
+	Texture2Index,
+	Texture2TransformationIndex,
+	TextureCoordinate2Index,
+	TransformationIndex,
+
+	 
+	NumStacks,
+    };
+
+    static const char *stackNames[NumStacks];	 
+
+    int		depth;		 
+    QvElement	**stacks;	 
+
+ 
+	BspLib ::VrmlFile *vrmlfile_base;
+	QvState( BspLib ::VrmlFile *base );
+ 
+
+    QvState();
+    ~QvState();
+
+     
+    void	addElement(StackIndex stackIndex, QvElement *elt);
+
+     
+    QvElement *	getTopElement(StackIndex stackIndex)
+	{ return stacks[stackIndex]; }
+
+     
+    void	push();
+    void	pop();
+
+     
+    void	popElement(StackIndex stackIndex);
+
+     
+    void	print();
+};
+
+
+# 3 "QvTraverse.cpp" 2
+
+
+
+
+
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+
+ 
+static int indent = 0;
+static void
+announce(const char *className)
+{
+    for (int i = 0; i < indent; i++)
+	printf("\t");
+    printf("Traversing a %s\n", className);
+}
+
+
+
+
+
+
+
+
+
+ 
+ 
+ 
+ 
+ 
+
+void
+QvGroup::traverse(QvState *state)
+{
+    announce("QvGroup" ) ;
+    indent++;
+    for (int i = 0; i < getNumChildren(); i++)
+	getChild(i)->traverse(state);
+    indent--;
+}
+
+void
+QvLevelOfDetail::traverse(QvState *state)
+{
+    announce("QvLevelOfDetail" ) ;
+    indent++;
+
+     
+     
+    if (getNumChildren() > 0)
+	getChild(0)->traverse(state);
+
+    indent--;
+}
+
+void
+QvSeparator::traverse(QvState *state)
+{
+    announce("QvSeparator" ) ;
+    state->push();
+    indent++;
+    for (int i = 0; i < getNumChildren(); i++)
+	getChild(i)->traverse(state);
+    indent--;
+    state->pop();
+}
+
+void
+QvSwitch::traverse(QvState *state)
+{
+    announce("QvSwitch" ) ;
+    indent++;
+
+    int which = whichChild.value;
+
+    if (which == (-1) )
+	;
+
+    else if (which == (-3) )
+	for (int i = 0; i < getNumChildren(); i++)
+	    getChild(i)->traverse(state);
+
+    else
+	if (which < getNumChildren())
+	    getChild(which)->traverse(state);
+
+    indent--;
+}
+
+void
+QvTransformSeparator::traverse(QvState *state)
+{
+    announce("QvTransformSeparator" ) ;
+
+     
+     
+     
+     
+
+    QvElement *markerElt = new QvElement;
+    markerElt->data = this;
+    markerElt->type = QvElement::NoOpTransform;
+    state->addElement(QvState::TransformationIndex, markerElt);
+
+    indent++;
+    for (int i = 0; i < getNumChildren(); i++)
+	getChild(i)->traverse(state);
+    indent--;
+
+     
+    while (state->getTopElement(QvState::TransformationIndex) != markerElt)
+	state->popElement(QvState::TransformationIndex);
+}
+
+ 
+ 
+ 
+ 
+ 
+
+
+# 139 "QvTraverse.cpp"
+
+
+# 150 "QvTraverse.cpp"
+
+
+void QvCoordinate3::traverse(QvState *state)
+{
+    announce("QvCoordinate3" ) ;
+    QvElement *elt = new QvElement;
+    elt->data = this;
+    state->addElement(QvState::Coordinate3Index, elt);
+
+ 
+ 
+
+
+
+ 
+
+	printf( "---------------------------------------\n" );
+}
+ 
+ 
+
+void	 QvMaterial ::traverse(QvState *state)	{	announce("QvMaterial" ) ;	QvElement *elt = new QvElement;	elt->data = this;	state->addElement(QvState:: 			MaterialIndex , elt);	} 
+void	 QvMaterialBinding ::traverse(QvState *state)	{	announce("QvMaterialBinding" ) ;	QvElement *elt = new QvElement;	elt->data = this;	state->addElement(QvState:: 		MaterialBindingIndex , elt);	} 
+void	 QvNormal ::traverse(QvState *state)	{	announce("QvNormal" ) ;	QvElement *elt = new QvElement;	elt->data = this;	state->addElement(QvState:: 			NormalIndex , elt);	} 
+void	 QvNormalBinding ::traverse(QvState *state)	{	announce("QvNormalBinding" ) ;	QvElement *elt = new QvElement;	elt->data = this;	state->addElement(QvState:: 		NormalBindingIndex , elt);	} 
+void	 QvShapeHints ::traverse(QvState *state)	{	announce("QvShapeHints" ) ;	QvElement *elt = new QvElement;	elt->data = this;	state->addElement(QvState:: 		ShapeHintsIndex , elt);	} 
+void	 QvTextureCoordinate2 ::traverse(QvState *state)	{	announce("QvTextureCoordinate2" ) ;	QvElement *elt = new QvElement;	elt->data = this;	state->addElement(QvState:: 	TextureCoordinate2Index , elt);	} 
+void	 QvTexture2 ::traverse(QvState *state)	{	announce("QvTexture2" ) ;	QvElement *elt = new QvElement;	elt->data = this;	state->addElement(QvState:: 			Texture2Index , elt);	} 
+void	 QvTexture2Transform ::traverse(QvState *state)	{	announce("QvTexture2Transform" ) ;	QvElement *elt = new QvElement;	elt->data = this;	state->addElement(QvState:: 	Texture2TransformationIndex , elt);	} 
+
+void	 QvDirectionalLight ::traverse(QvState *state)	{	announce("QvDirectionalLight" ) ;	QvElement *elt = new QvElement;	elt->data = this;	elt->type = QvElement::  DirectionalLight ;	state->addElement(QvState:: 	LightIndex , elt);	} 
+void	 QvPointLight ::traverse(QvState *state)	{	announce("QvPointLight" ) ;	QvElement *elt = new QvElement;	elt->data = this;	elt->type = QvElement::  PointLight ;	state->addElement(QvState:: 		LightIndex , elt);	} 
+void	 QvSpotLight ::traverse(QvState *state)	{	announce("QvSpotLight" ) ;	QvElement *elt = new QvElement;	elt->data = this;	elt->type = QvElement::  SpotLight ;	state->addElement(QvState:: 		LightIndex , elt);	} 
+
+void	 QvOrthographicCamera ::traverse(QvState *state)	{	announce("QvOrthographicCamera" ) ;	QvElement *elt = new QvElement;	elt->data = this;	elt->type = QvElement::  OrthographicCamera ;	state->addElement(QvState:: 	CameraIndex , elt);	} 
+void	 QvPerspectiveCamera ::traverse(QvState *state)	{	announce("QvPerspectiveCamera" ) ;	QvElement *elt = new QvElement;	elt->data = this;	elt->type = QvElement::  PerspectiveCamera ;	state->addElement(QvState:: 	CameraIndex , elt);	} 
+
+void	 QvTransform ::traverse(QvState *state)	{	announce("QvTransform" ) ;	QvElement *elt = new QvElement;	elt->data = this;	elt->type = QvElement::  Transform ;	state->addElement(QvState:: 	     TransformationIndex , elt);	} 
+void	 QvRotation ::traverse(QvState *state)	{	announce("QvRotation" ) ;	QvElement *elt = new QvElement;	elt->data = this;	elt->type = QvElement::  Rotation ;	state->addElement(QvState:: 	     TransformationIndex , elt);	} 
+void	 QvMatrixTransform ::traverse(QvState *state)	{	announce("QvMatrixTransform" ) ;	QvElement *elt = new QvElement;	elt->data = this;	elt->type = QvElement::  MatrixTransform ;	state->addElement(QvState::  TransformationIndex , elt);	} 
+void	 QvTranslation ::traverse(QvState *state)	{	announce("QvTranslation" ) ;	QvElement *elt = new QvElement;	elt->data = this;	elt->type = QvElement::  Translation ;	state->addElement(QvState::      TransformationIndex , elt);	} 
+void	 QvScale ::traverse(QvState *state)	{	announce("QvScale" ) ;	QvElement *elt = new QvElement;	elt->data = this;	elt->type = QvElement::  Scale ;	state->addElement(QvState:: 	     TransformationIndex , elt);	} 
+
+ 
+ 
+ 
+ 
+ 
+
+static void
+printProperties(QvState *state)
+{
+    printf("--------------------------------------------------------------\n");
+    state->print();
+    printf("--------------------------------------------------------------\n");
+}
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+ 
+
+ 
+ 
+ 
+ 
+
+
+# 1 "../BspLib/BRep.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+
+
+
+# 1 "../BspLib/Transform2.h" 1
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+ 
+
+
+
+
+namespace BspLib  { 
+
+
+ 
+ 
+class Transform2 {
+
+	friend Transform2 operator *( const Transform2& trafo1, const Transform2& trafo2 );
+
+public:
+	Transform2();
+	Transform2( const float trafo[3][3] );
+	Transform2( const double trafo[3][3] );
+	~Transform2() { }
+
+	 
+	Vector2		TransformVector2( const Vector2& vec ) const;
+
+	double		Determinant();						 
+	int			Inverse( Transform2& inverse );		 
+
+	 
+	Transform2&	Concat( const Transform2& cattrafo );
+	Transform2&	ConcatR( const Transform2& cattrafo );
+
+	 
+	Transform2&	LoadIdentity();
+	Transform2&	LoadRotation( double angle );
+	Transform2&	LoadScale( double x, double y );
+	Transform2&	LoadTranslation( double x, double y );
+
+	 
+	Transform2&	Rotate( double angle );
+	Transform2&	Scale( double x, double y );
+	Transform2&	Translate( double x, double y );
+
+	 
+	Transform2&	RotateR( double angle );
+	Transform2&	ScaleR( double x, double y );
+	Transform2&	TranslateR( double x, double y );
+
+	 
+	Vector2		FetchTranslation() const;
+	Vector2		ExtractTranslation();
+
+	 
+	double *	LinMatrixAccess() { return (double *) m_matrix; }
+
+private:
+	 
+	double	m_matrix[3][3];
+};
+
+ 
+inline Transform2& Transform2::LoadIdentity()
+{
+	memset( m_matrix, 0, sizeof( m_matrix ) );
+
+	m_matrix[ 0 ][ 0 ] = 1.0;
+	m_matrix[ 1 ][ 1 ] = 1.0;
+	m_matrix[ 2 ][ 2 ] = 1.0;
+
+	return *this;
+}
+
+ 
+inline Transform2::Transform2()
+{
+ 
+}
+
+ 
+inline Transform2::Transform2( const double trafo[3][3] )
+{
+	 
+	 
+	 
+	memcpy( m_matrix, trafo, sizeof( m_matrix ) );
+}
+
+ 
+inline Transform2::Transform2( const float trafo[3][3] )
+{
+	 
+	 
+	 
+	for ( int i = 0; i < 9; i++ )
+		((double *)m_matrix)[ i ] = (double) ((float *)trafo)[ i ];
+}
+
+
+} 
+
+
+
+
+# 16 "../BspLib/BRep.h" 2
+
+
+
+ 
+
+
+
+
+
+
+
+
+namespace BspLib  { 
+
+
+ 
+ 
+class BRep : public virtual SystemIO {
+
+public:
+	BRep( QvState *state );
+	~BRep() { }
+
+	void			BuildFromSpherePrimitive( const QvSphere& spherenode );
+	void			BuildFromConePrimitive( const QvCone& spherenode );
+	void			BuildFromCubePrimitive( const QvCube& spherenode );
+	void			BuildFromCylinderPrimitive( const QvCylinder& spherenode );
+	void			BuildFromIndexedFaceSet( const QvIndexedFaceSet& faceset );
+
+public:
+	static int		getTriangulation() { return do_triangulation; }
+	static void		setTriangulation( int tri ) { do_triangulation = tri; }
+
+	static int		getTessellation() { return tessellation_slices; }
+	static void		setTessellation( int tes ) { tessellation_slices = tes; }
+
+	static int		getMaterialFlag() { return use_material_spec; }
+	static void		setMaterialFlag( int mfl ) { use_material_spec = mfl; }
+
+	static int		getMirrorTextureVFlag() { return mirror_v_axis; }
+	static void		setMirrorTextureVFlag( int mtv ) { mirror_v_axis = mtv; }
+
+private:
+	float*			FetchCoordinate3State( int &num );
+	float*			FetchTextureCoordinate2State( int &num );
+	float*			FetchNormalState( int &num );
+	void			FetchTransformationState( Transform3& trafo );
+	void			FetchTextureTransformationState( Transform2& trafo );
+	int				FetchMaterialState( Material& mat, int indx );
+	void			FetchMaterialBindingState( int& binding );
+	void			FetchNormalBindingState( int& binding );
+	void			FetchShapeHintsState();
+	Texture*		CheckTexture2State();
+	void			CreateIndexedFace( Texture *texture, int curindex, int numtexindexs, long *texindexs, int v1, int v2, int v3 );
+	void			PostProcessObject();
+
+private:
+	static int		shapehint_vertexOrdering;
+	static int		shapehint_shapeType;
+	static int		shapehint_faceType;
+	static float	shapehint_creaseAngle;
+
+	static int		use_material_spec;
+	static int		mirror_v_axis;
+	static int		do_triangulation;
+	static int		tessellation_slices;
+
+private:
+	QvState*		m_state;
+	BspObject*		m_baseobject;
+};
+
+
+} 
+
+
+
+
+# 239 "QvTraverse.cpp" 2
+
+
+void QvSphere::traverse(QvState *state)
+{
+	announce("QvSphere" ) ;
+	BspLib ::BRep brep( state );
+	brep.BuildFromSpherePrimitive( *this );
+}
+
+void QvCone::traverse(QvState *state)
+{
+	announce("QvCone" ) ;
+	BspLib ::BRep brep( state );
+	brep.BuildFromConePrimitive( *this );
+}
+
+void QvCube::traverse(QvState *state)
+{
+	announce("QvCube" ) ;
+	BspLib ::BRep brep( state );
+	brep.BuildFromCubePrimitive( *this );
+}
+
+
+void QvCylinder::traverse(QvState *state)
+{
+	announce("QvCylinder" ) ;
+	BspLib ::BRep brep( state );
+	brep.BuildFromCylinderPrimitive( *this );
+}
+
+void QvIndexedFaceSet::traverse(QvState *state)
+{
+	announce("QvIndexedFaceSet" ) ;
+ 
+
+
+
+
+	 
+	BspLib ::BRep brep( state );
+	brep.BuildFromIndexedFaceSet( *this );
+}
+ 
+
+ 
+ 
+
+void	 QvIndexedLineSet ::traverse(QvState *state)	{	announce("QvIndexedLineSet" ) ;	printProperties(state);	} 
+void	 QvPointSet ::traverse(QvState *state)	{	announce("QvPointSet" ) ;	printProperties(state);	} 
+
+
+
+ 
+ 
+ 
+ 
+ 
+
+ 
+void	 QvWWWAnchor ::traverse(QvState *)	{	announce("QvWWWAnchor" ) ;	} 
+void	 QvWWWInline ::traverse(QvState *)	{	announce("QvWWWInline" ) ;	} 
+
+ 
+ 
+ 
+ 
+ 
+
+void	 QvInfo ::traverse(QvState *)	{	announce("QvInfo" ) ;	} 
+void	  QvUnknownNode ::traverse(QvState *)	{	announce("QvUnknownNode" ) ;	} 
+
+ 
+
+
+
+
+
+