This is my initial working version.

There is a bug in boot in this version: subhurd sometimes cannot boot.

39 files changed, 40006 insertions, 0 deletions

diff --git a/netfs-sample/.DS_Store b/netfs-sample/.DS_Store
new file mode 100644
index 00000000..1b3548e4
--- /dev/null
+++ b/netfs-sample/.DS_Store
diff --git a/netfs-sample/._.DS_Store b/netfs-sample/._.DS_Store
new file mode 100644
index 00000000..460d887a
--- /dev/null
+++ b/netfs-sample/._.DS_Store
diff --git a/netfs-sample/._README b/netfs-sample/._README
new file mode 100644
index 00000000..7890b844
--- /dev/null
+++ b/netfs-sample/._README
diff --git a/netfs-sample/._build b/netfs-sample/._build
new file mode 100755
index 00000000..fdbbe05f
--- /dev/null
+++ b/netfs-sample/._build
diff --git a/netfs-sample/._debug.h b/netfs-sample/._debug.h
new file mode 100644
index 00000000..64df4703
--- /dev/null
+++ b/netfs-sample/._debug.h
diff --git a/netfs-sample/._filterfs.c b/netfs-sample/._filterfs.c
new file mode 100644
index 00000000..fb38f699
--- /dev/null
+++ b/netfs-sample/._filterfs.c
diff --git a/netfs-sample/._filterfs.h b/netfs-sample/._filterfs.h
new file mode 100644
index 00000000..5def824d
--- /dev/null
+++ b/netfs-sample/._filterfs.h
diff --git a/netfs-sample/._lib.c b/netfs-sample/._lib.c
new file mode 100644
index 00000000..753b651b
--- /dev/null
+++ b/netfs-sample/._lib.c
diff --git a/netfs-sample/._lib.h b/netfs-sample/._lib.h
new file mode 100644
index 00000000..700c364d
--- /dev/null
+++ b/netfs-sample/._lib.h
diff --git a/netfs-sample/._lnode.c b/netfs-sample/._lnode.c
new file mode 100644
index 00000000..3ff1f825
--- /dev/null
+++ b/netfs-sample/._lnode.c
diff --git a/netfs-sample/._lnode.h b/netfs-sample/._lnode.h
new file mode 100644
index 00000000..c048807a
--- /dev/null
+++ b/netfs-sample/._lnode.h
diff --git a/netfs-sample/._ncache.c b/netfs-sample/._ncache.c
new file mode 100644
index 00000000..59c6084d
--- /dev/null
+++ b/netfs-sample/._ncache.c
diff --git a/netfs-sample/._ncache.h b/netfs-sample/._ncache.h
new file mode 100644
index 00000000..3d1e37b9
--- /dev/null
+++ b/netfs-sample/._ncache.h
diff --git a/netfs-sample/._node.c b/netfs-sample/._node.c
new file mode 100644
index 00000000..812144e0
--- /dev/null
+++ b/netfs-sample/._node.c
diff --git a/netfs-sample/._node.c~ b/netfs-sample/._node.c~
new file mode 100644
index 00000000..f63df45b
--- /dev/null
+++ b/netfs-sample/._node.c~
diff --git a/netfs-sample/._node.h b/netfs-sample/._node.h
new file mode 100644
index 00000000..041c8330
--- /dev/null
+++ b/netfs-sample/._node.h
diff --git a/netfs-sample/._options.c b/netfs-sample/._options.c
new file mode 100644
index 00000000..b7e5716f
--- /dev/null
+++ b/netfs-sample/._options.c
diff --git a/netfs-sample/._options.h b/netfs-sample/._options.h
new file mode 100644
index 00000000..b46d37fe
--- /dev/null
+++ b/netfs-sample/._options.h
diff --git a/netfs-sample/README b/netfs-sample/README
new file mode 100644
index 00000000..112cce59
--- /dev/null
+++ b/netfs-sample/README
@@ -0,0 +1,13 @@
+FILTERFS TRANSLATOR
+
+WHAT'S THIS?
+filterfs is a GNU/Hurd translator that filters the contents of the directory it 
+is set upon according to the result of execution of a given command.
+
+WHAT'S IT FOR?
+This translator is intended as a preparatory exercise for the namespace-based 
+translator selection project (see http://www.bddebian.com/~wiki/community/gsoc/), 
+so it does not really have a stand-alone importance :-)
+
+DEVELOPER
+Sergiu Ivanov <unlimitedscolobb@gmail.com>
diff --git a/netfs-sample/build b/netfs-sample/build
new file mode 100755
index 00000000..2555e2ca
--- /dev/null
+++ b/netfs-sample/build
@@ -0,0 +1 @@
+gcc -Wall -g -lnetfs -lfshelp -liohelp -lthreads -lports -lihash -lshouldbeinlibc -o filterfs filterfs.c node.c lnode.c ncache.c options.c lib.c 2>&1 | tee errors
diff --git a/netfs-sample/cscope.out b/netfs-sample/cscope.out
new file mode 100644
index 00000000..0dc6229b
--- /dev/null
+++ b/netfs-sample/cscope.out
@@ -0,0 +1,33870 @@
+cscope 15 $HOME/Desktop/netfs-sample               0000194972
+	@debug.h
+
+26 #i�de�
+__DEBUG_H__
+
+
+27 

+	#__DEBUG_H__
+
+
+	)
+
+30 
+	~<�dio.h
+>
+
+36 

+	#DEBUG_OUTPUT
+ "/v�/tmp/f��rfs.dbg"
+
+	)
+
+38 #ifde�
+DEBUG
+
+
+40 

+	#INIT_LOG
+(�
+f��rfs_dbg
+ = 
+	`fݒ
+(
+DEBUG_OUTPUT
+, "wt")
+
+	)
+
+42 

+	#CLOSE_LOG
+(�
+	`f�o�
+(
+f��rfs_dbg
+)
+
+	)
+
+44 

+	#LOG_MSG
+(
+fmt
+, 
+�gs
+...�{
+	`�r�tf
+(
+f��rfs_dbg
+, fmt"\n", ##args);\
+
+45 
+	`f�ush
+(
+f��rfs_dbg
+);}
+
+	)
+
+48 

+	#INIT_LOG
+()
+
+	)
+
+49 

+	#CLOSE_LOG
+()
+
+	)
+
+50 

+	#LOG_MSG
+(
+fmt
+, 
+�gs
+...)
+
+	)
+
+57 

+FILE
+ * 
+f��rfs_dbg
+;
+
+	@filterfs.c
+
+28 

+	#_GNU_SOURCE
+ 1
+
+	)
+
+30 
+	~"f��rfs.h
+"
+
+32 
+	~<�r�.h
+>
+
+33 
+	~<�gp.h
+>
+
+34 
+	~<�gz.h
+>
+
+35 
+	~<hurd/�tfs.h
+>
+
+36 
+	~<f��.h
+>
+
+38 
+	~"debug.h
+"
+
+39 
+	~"�ti�s.h
+"
+
+40 
+	~"n�che.h
+"
+
+46 

+	#OPENONLY_STATE_MODES
+ (
+O_CREAT
+ | 
+O_EXCL
+ | 
+O_NOLINK
+ | 
+O_NOTRANS
+ \
+
+47 | 
+O_NONBLOCK
+)
+
+	)
+
+53 * 
+	g�tfs_�rv�_�me
+ = "filterfs";
+
+56 * 
+	g�tfs_�rv�_v�si�
+ = "0.0";
+
+59 
+	g�tfs_maxsyml�ks
+ = 12;
+
+62 
+mach_p�t_t
+ 
+	gund�ly�g_node
+;
+
+65 
+io_��buf_t
+ 
+	gund�ly�g_node_��
+;
+
+68 vީ��
+m��d_time_v�ue
+ * 
+	gm�time
+;
+
+71 
+pid_t
+ 
+	gfsid
+;
+
+74 
+FILE
+ * 
+	gf��rfs_dbg
+;
+
+80 
+�r�_t
+
+
+81 
+	g�tfs_��m�_���_f�e
+
+
+83 
+iou�r
+ * 
+	gu�r
+,
+
+84 
+node
+ * 
+	gd�
+,
+
+85 * 
+	g�me
+,
+
+86 
+mode_t
+ 
+	gmode
+,
+
+87 
+node
+ ** 
+	gnode
+
+
+90 
+LOG_MSG
+("netfs_attempt_create_file");
+
+93 
+mu�x_u�ock
+(&
+d�
+->
+lock
+);
+
+94  
+	gEOPNOTSUPP
+;
+
+99 
+�r�_t
+
+
+100 
+	g�tfs_check_ݒ_�rmissi�s
+
+
+102 
+iou�r
+ * 
+	gu�r
+,
+
+103 
+node
+ * 
+	g�
+,
+
+104 
+	g�ags
+,
+
+105 
+	g�wnode
+
+
+108 
+LOG_MSG
+("�tfs_check_ݒ_�rmissi�s: '%s'", 
+�
+->
+�
+->
+�ode
+->
+�me
+);
+
+110 
+�r�_t
+ 
+	g�r
+ = 0;
+
+113 if(
+	g�ags
+ & 
+	gO_READ
+)
+
+114 
+	g�r
+ = 
+fsh�p_ac�ss
+(&
+�
+->
+�_��
+, 
+S_IREAD
+, 
+u�r
+);
+
+115 if(!
+	g�r
+ && (
+	g�ags
+ & 
+	gO_WRITE
+))
+
+116 
+	g�r
+ = 
+fsh�p_ac�ss
+(&
+�
+->
+�_��
+, 
+S_IWRITE
+, 
+u�r
+);
+
+117 if(!
+	g�r
+ && (
+	g�ags
+ & 
+	gO_EXEC
+))
+
+118 
+	g�r
+ = 
+fsh�p_ac�ss
+(&
+�
+->
+�_��
+, 
+S_IEXEC
+, 
+u�r
+);
+
+121  
+	g�r
+;
+
+125 
+�r�_t
+
+
+126 
+	g�tfs_��m�_utimes
+
+
+128 
+iou�r
+ * 
+	g�ed
+,
+
+129 
+node
+ * 
+	gnode
+,
+
+130 
+time�ec
+ * 
+	g�ime
+,
+
+131 
+time�ec
+ * 
+	gmtime
+
+
+134 
+LOG_MSG
+("netfs_attempt_utimes");
+
+136 
+�r�_t
+ 
+	g�r
+ = 0;
+
+139 
+	g�ags
+ = 
+TOUCH_CTIME
+;
+
+142 
+	g�r
+ = 
+fsh�p_isow�r
+(&
+node
+->
+�_��
+, 
+�ed
+);
+
+145 if(!
+	g�r
+)
+
+148 if(
+	g�ime
+)
+
+150 
+	gnode
+->
+	g�_��
+.
+	g�_�im
+ = *
+�ime
+;
+
+153 
+	g�ags
+ |�
+TOUCH_ATIME
+;
+
+156 if(
+	gmtime
+)
+
+158 
+	gnode
+->
+	g�_��
+.
+	g�_mtim
+ = *
+mtime
+;
+
+161 
+	g�ags
+ |�
+TOUCH_MTIME
+;
+
+164 
+fsh�p_touch
+(&
+node
+->
+�_��
+, 
+�ags
+, 
+m�time
+);
+
+168  
+	g�r
+;
+
+172 
+�r�_t
+
+
+173 
+	g�tfs_�p�t_ac�ss
+
+
+175 
+iou�r
+ * 
+	g�ed
+,
+
+176 
+node
+ * 
+	g�
+,
+
+177 * 
+	gty�s
+
+
+180 
+LOG_MSG
+("netfs_report_access");
+
+183 *
+	gty�s
+ = 0;
+
+186 if(
+fsh�p_ac�ss
+(&
+�
+->
+�_��
+, 
+S_IREAD
+, 
+�ed
+) == 0)
+
+187 *
+ty�s
+ |�
+O_READ
+;
+
+188 if(
+fsh�p_ac�ss
+(&
+�
+->
+�_��
+, 
+S_IWRITE
+, 
+�ed
+) == 0)
+
+189 *
+ty�s
+ |�
+O_WRITE
+;
+
+190 if(
+fsh�p_ac�ss
+(&
+�
+->
+�_��
+, 
+S_IEXEC
+, 
+�ed
+) == 0)
+
+191 *
+ty�s
+ |�
+O_EXEC
+;
+
+198 
+�r�_t
+
+
+199 
+	g�tfs_v�id�e_��
+
+
+201 
+node
+ * 
+	g�
+,
+
+202 
+iou�r
+ * 
+	g�ed
+
+
+205 
+LOG_MSG
+("�tfs_v�id�e_��: '%s'", 
+�
+->
+�
+->
+�ode
+->
+�me
+);
+
+207 
+�r�_t
+ 
+	g�r
+ = 0;
+
+210 if(
+	g�
+ !�
+�tfs_ro�_node
+)
+
+213 if(!(
+�
+->
+�
+->
+�ags
+ & 
+FLAG_NODE_ULFS_UPTODATE
+))
+
+216 
+�r
+ = 
+node_upd�e
+(
+�
+);
+
+220 if(!
+	g�r
+)
+
+223 if(
+	g�
+->
+	g�
+->
+	gp�t
+ !�
+MACH_PORT_NULL
+)
+
+229 
+�r
+ = 
+io_��
+(
+�
+->
+�
+->
+p�t
+, &�->
+�_��
+);
+
+232 if(!
+	g�r
+)
+
+234 
+	g�
+->
+	g�_����ed
+ = 
+�
+->
+�_��
+.
+�_mode
+;
+
+243 
+node_t
+ * 
+	gd�
+;
+
+246 
+	g�r
+ = 
+n�che_node_lookup
+(
+�
+->
+�
+->
+�ode
+->
+d�
+, &
+d�
+);
+
+249 
+as��
+(!
+�r
+);
+
+252 
+mach_p�t_t
+ 
+	gp
+ = 
+f�e_�me_lookup_und�
+
+
+253 (
+d�
+->
+�
+->
+p�t
+, 
+	g�
+->
+	g�
+->
+	g�ode
+->
+	g�me
+, 0, 0);
+
+256 
+�tfs_�ut
+(
+d�
+);
+
+258 if(!
+	gp
+)
+
+259  
+	gEBADF
+;
+
+262 
+	g�r
+ = 
+io_��
+(
+p
+, &
+�
+->
+�_��
+);
+
+265 
+PORT_DEALLOC
+(
+p
+);
+
+272 
+node_g�_size
+(
+�
+, (
+OFFSET_T
+ *)&�->
+�_��
+.
+�_size
+);
+
+275  
+	g�r
+;
+
+279 
+�r�_t
+
+
+280 
+	g�tfs_��m�_sync
+
+
+282 
+iou�r
+ * 
+	g�ed
+,
+
+283 
+node
+ * 
+	gnode
+,
+
+284 
+	gwa�
+
+
+287 
+LOG_MSG
+("netfs_attempt_sync");
+
+290  
+	gEOPNOTSUPP
+;
+
+294 
+�r�_t
+
+
+295 
+	g�tfs_g�_d��ts
+
+
+297 
+iou�r
+ * 
+	g�ed
+,
+
+298 
+node
+ * 
+	gd�
+,
+
+299 
+	gf��_��y
+,
+
+300 
+	gnum_���s
+,
+
+301 ** 
+	gd�a
+,
+
+302 
+mach_msg_ty�_numb�_t
+ * 
+	gd�a_�n
+,
+
+303 
+vm_size_t
+ 
+	gmax_d�a_�n
+,
+
+304 * 
+	gd�a_���s
+
+
+307 
+LOG_MSG
+("�tfs_g�_d��ts: '%s'", 
+d�
+->
+�
+->
+�ode
+->
+�me
+);
+
+309 
+�r�_t
+ 
+	g�r
+;
+
+312 
+node_d��t_t
+ * 
+	gd��t_��t
+, * 
+	gd��t_cu��t
+;
+
+315 
+node_d��t_t
+ * 
+	gd��t_li�
+ = 
+NULL
+;
+
+318 
+size_t
+ 
+	gsize
+ = 0;
+
+321 
+	gcou�
+ = 0;
+
+324 * 
+	gd�a_p
+;
+
+328 
+	gbump_size
+
+
+330 cڡ * 
+	g�me
+
+
+334 if((
+	gnum_���s
+ =�-1�|| (
+cou�
+ < 
+num_���s
+))
+
+337 
+size_t
+ 
+�w_size
+ = 
+size
+ + 
+DIRENT_LEN
+(
+���
+(
+�me
+));
+
+340 if((
+	gmax_d�a_�n
+ > 0�&& (
+	g�w_size
+ > max_data_len))
+
+345 
+	gsize
+ = 
+�w_size
+;
+
+348 ++
+	gcou�
+;
+
+362 
+	gadd_d��t
+
+
+364 cڡ * 
+	g�me
+,
+
+365 
+�o_t
+ 
+	g�o
+,
+
+366 
+	gty�
+
+
+370 if((
+	gnum_���s
+ =�-1�|| (
+cou�
+ < 
+num_���s
+))
+
+373 
+d��t
+ 
+hdr
+;
+
+376 
+size_t
+ 
+	g�me_�n
+ = 
+���
+(
+�me
+);
+
+379 
+size_t
+ 
+	gsz
+ = 
+DIRENT_LEN
+(
+�me_�n
+);
+
+382 if(
+	gsz
+ > 
+	gsize
+)
+
+387 
+	gsize
+ -�
+sz
+;
+
+390 
+	ghdr
+.
+	gd_�o
+ = 
+�o
+;
+
+391 
+	ghdr
+.
+	gd_���
+ = 
+sz
+;
+
+392 
+	ghdr
+.
+	gd_ty�
+ = 
+ty�
+;
+
+393 
+	ghdr
+.
+	gd_�m�n
+ = 
+�me_�n
+;
+
+400 
+mem�y
+(
+d�a_p
+, &
+hdr
+, 
+DIRENT_NAME_OFFS
+);
+
+403 
+�r�y
+(
+d�a_p
+ + 
+DIRENT_NAME_OFFS
+, 
+�me
+);
+
+408 
+	gd�a_p
+ +�
+sz
+;
+
+411 ++
+	gcou�
+;
+
+422 
+	g�r
+ = 
+node_���s_g�
+(
+d�
+, &
+d��t_li�
+);
+
+425 if(!
+	g�r
+)
+
+430 
+	gd��t_��t
+ = 
+d��t_li�
+, 
+	gcou�
+ = 2;
+
+431 
+	gd��t_��t
+ && (
+	gcou�
+ < 
+	gf��_��y
+);
+
+432 
+	gd��t_��t
+ = 
+d��t_��t
+->
+�xt
+, ++
+	gcou�
+
+
+436 
+	gcou�
+ = 0;
+
+439 if(
+	gf��_��y
+ == 0)
+
+440 
+bump_size
+(".");
+
+441 if(
+	gf��_��y
+ <= 1)
+
+442 
+bump_size
+("..");
+
+447 
+	gd��t_cu��t
+ = 
+d��t_��t
+;
+
+448 
+	gd��t_cu��t
+;
+
+449 
+	gd��t_cu��t
+ = 
+d��t_cu��t
+->
+�xt
+
+
+452 if(
+bump_size
+(
+d��t_cu��t
+->
+d��t
+->
+d_�me
+) == 0)
+
+457 *
+	gd�a
+ = 
+mm�
+(0, 
+size
+, 
+PROT_READ
+ | 
+PROT_WRITE
+, 
+MAP_ANON
+, 0, 0);
+
+460 
+	g�r
+ = ((*)*
+d�a
+ =�
+MAP_FAILED
+�? (
+��o
+) : (0);
+
+464 if(!
+	g�r
+)
+
+467 
+	gd�a_p
+ = *
+d�a
+;
+
+470 *
+	gd�a_�n
+ = 
+size
+;
+
+471 *
+	gd�a_���s
+ = 
+cou�
+;
+
+474 
+	gcou�
+ = 0;
+
+477 if(
+	gf��_��y
+ == 0)
+
+478 
+add_d��t
+(".", 2, 
+DT_DIR
+);
+
+479 if(
+	gf��_��y
+ <= 1)
+
+480 
+add_d��t
+("..", 2, 
+DT_DIR
+);
+
+485 
+	gd��t_cu��t
+ = 
+d��t_��t
+; dirent_current;
+
+486 
+	gd��t_cu��t
+ = 
+d��t_cu��t
+->
+�xt
+
+
+491 
+add_d��t
+
+
+492 (
+d��t_cu��t
+->
+d��t
+->
+d_�me
+, 
+	gd��t_cu��t
+->
+	gd��t
+->
+	gd_f��o
+,
+
+493 
+	gd��t_cu��t
+->
+	gd��t
+->
+	gd_ty�
+) == 0
+
+500 if(
+	gd��t_li�
+)
+
+501 
+node_���s_�
+(
+d��t_li�
+);
+
+504 
+fsh�p_touch
+(&
+d�
+->
+�_��
+, 
+TOUCH_ATIME
+, 
+m�time
+);
+
+507  
+	g�r
+;
+
+511 
+�r�_t
+
+
+512 
+	g�tfs_��m�_lookup
+
+
+514 
+iou�r
+ * 
+	gu�r
+,
+
+515 
+node
+ * 
+	gd�
+,
+
+516 * 
+	g�me
+,
+
+517 
+node
+ ** 
+	gnode
+
+
+520 
+LOG_MSG
+("�tfs_��m�_lookup: '%s'", 
+�me
+);
+
+522 
+�r�_t
+ 
+	g�r
+ = 0;
+
+525 if(
+�rcmp
+(
+�me
+, ".") == 0)
+
+528 
+�tfs_�ef
+(
+d�
+);
+
+529 *
+	gnode
+ = 
+d�
+;
+
+535 if(
+�rcmp
+(
+�me
+, "..") == 0)
+
+538 if(
+d�
+->
+�
+->
+�ode
+->dir)
+
+541 
+as��
+(
+d�
+->
+�
+->
+�ode
+->d�->
+node
+);
+
+544 
+	g�r
+ = 
+n�che_node_lookup
+(
+d�
+->
+�
+->
+�ode
+->d�, 
+node
+);
+
+550 
+	g�r
+ = 
+ENOENT
+;
+
+551 *
+	gnode
+ = 
+NULL
+;
+
+555 
+mu�x_u�ock
+(&
+d�
+->
+lock
+);
+
+558  
+	g�r
+;
+
+563 
+	gcheck_�ݔty
+
+
+565 cڡ * 
+	g�me
+
+
+569 if(!
+	g�ݔty
+)
+
+574 
+	g��m_���s_cou�
+ = 0;
+
+577 * 
+	goccu���
+ = 
+�r�r
+(
+�ݔty
+, 
+PROPERTY_PARAM
+);
+
+580 ; 
+	goccu���
+;
+
+581 
+	goccu���
+ = 
+�r�r
+(
+occu���
+ + 1, 
+PROPERTY_PARAM
+),
+
+582 ++
+	g��m_���s_cou�
+);
+
+585 
+size_t
+ 
+	g�ݔty_��m_�n
+ = 
+���
+(
+PROPERTY_PARAM
+);
+
+588 
+size_t
+ 
+	g�ݔty_�n
+ = (
+�ݔty
+�? (
+���
+(property)) : (0);
+
+591 
+	g�r
+ = 0;
+
+594 
+size_t
+ 
+	gfu�_�me_�n
+ = 
+���
+(
+d�
+->
+�
+->
+�ode
+->
+�th
+�+ 1 + s��n(
+�me
+) + 1;
+
+597 * 
+	gfu�_�me
+ = 
+m�loc
+(
+fu�_�me_�n
+);
+
+598 if(!
+	gfu�_�me
+)
+
+600 
+	g�r
+ = 
+ENOMEM
+;
+
+605 
+	gfu�_�me
+[0] = 0;
+
+608 
+�r�y
+(
+fu�_�me
+, 
+d�
+->
+�
+->
+�ode
+->
+�th
+);
+
+609 
+�r�t
+(
+fu�_�me
+, "/");
+
+610 
+�r�t
+(
+fu�_�me
+, 
+�me
+);
+
+612 
+LOG_MSG
+("�tfs_��m�_lookup: A�ly�g f���t�%s...", 
+fu�_�me
+);
+
+615 
+size_t
+ 
+	gsz
+ = 
+�ݔty_�n
+ + (
+���
+(
+fu�_�me
+�- 
+�ݔty_��m_�n
+)
+
+616 * 
+��m_���s_cou�
+;
+
+619 * 
+	gcmd
+ = 
+m�loc
+(
+sz
+);
+
+620 if(!
+	gcmd
+)
+
+622 
+�
+(
+fu�_�me
+);
+
+623 
+	g�r
+ = 
+ENOMEM
+;
+
+628 
+	gcmd
+[0] = 0;
+
+631 * 
+	gp
+ = 
+�r�r
+(
+�ݔty
+, 
+PROPERTY_PARAM
+);
+
+634 * 
+	g��p
+ = 
+�ݔty
+;
+
+637 ; 
+	gp
+;� = 
+�r�r
+(
+��p
+, 
+PROPERTY_PARAM
+))
+
+640 
+���t
+(
+cmd
+, 
+��p
+, 
+p
+ -�ropp);
+
+643 
+�r�t
+(
+cmd
+, 
+fu�_�me
+);
+
+648 
+	g��p
+ = 
+p
+ + 
+�ݔty_��m_�n
+;
+
+654 
+�r�t
+(
+cmd
+, 
+��p
+);
+
+659 
+	gxcode
+ = 
+WEXITSTATUS
+(
+sy�em
+(
+cmd
+));
+
+662  
+	gxcode
+;
+
+666 if(
+check_�ݔty
+(
+�me
+) != 0)
+
+669 
+mu�x_u�ock
+(&
+d�
+->
+lock
+);
+
+672  
+	gENOENT
+;
+
+676 
+mach_p�t_t
+ 
+	gp
+ = 
+f�e_�me_lookup_und�
+(
+d�
+->
+�
+->
+p�t
+, 
+�me
+, 0, 0);
+
+679 if(
+	gp
+ =�
+MACH_PORT_NULL
+)
+
+682 
+mu�x_u�ock
+(&
+d�
+->
+lock
+);
+
+685  
+	gENOENT
+;
+
+689 
+io_��buf_t
+ 
+	g��
+;
+
+690 
+	g�r
+ = 
+io_��
+(
+p
+, &
+��
+);
+
+693 
+PORT_DEALLOC
+(
+p
+);
+
+696 if(
+	g�r
+ || !
+S_ISDIR
+(
+��
+.
+�_mode
+))
+
+699 
+	gp
+ = 
+MACH_PORT_NULL
+;
+
+704 
+	gp
+ = 
+f�e_�me_lookup_und�
+(
+d�
+->
+�
+->
+p�t
+, 
+�me
+, 
+O_READ
+ | 
+O_DIRECTORY
+, 0);
+
+705 if(
+	gp
+ =�
+MACH_PORT_NULL
+)
+
+707  
+EBADF
+;
+
+712 
+�ode_t
+ * 
+	g�ode
+;
+
+716 
+f��ize
+()
+
+719 if(
+	g�r
+)
+
+722 *
+	gnode
+ = 
+NULL
+;
+
+725 if(
+	gp
+ !�
+MACH_PORT_NULL
+)
+
+726 
+PORT_DEALLOC
+(
+p
+);
+
+729 if(*
+	gnode
+)
+
+732 
+mu�x_u�ock
+(&(*
+node
+)->
+lock
+);
+
+735 
+n�che_node_add
+(*
+node
+);
+
+739 
+mu�x_u�ock
+(&
+d�
+->
+�
+->
+�ode
+->
+lock
+);
+
+740 
+mu�x_u�ock
+(&
+d�
+->
+lock
+);
+
+744 
+	g�r
+ = 
+�ode_g�
+(
+d�
+->
+�
+->
+�ode
+, 
+�me
+, &lnode);
+
+747 if(
+	g�r
+ =�
+ENOENT
+)
+
+750 
+�r
+ = 
+�ode_���
+(
+�me
+, &
+�ode
+);
+
+751 if(
+	g�r
+)
+
+753 
+f��ize
+();
+
+754  
+	g�r
+;
+
+758 
+�ode_���l
+(
+d�
+->
+�
+->
+�ode
+,�node);
+
+762 
+	g�r
+ = 
+n�che_node_lookup
+(
+�ode
+, 
+node
+);
+
+765 
+�ode_�f_�move
+(
+�ode
+);
+
+768 if(
+	g�r
+)
+
+771 
+f��ize
+();
+
+772  
+	g�r
+;
+
+776 (*
+	gnode
+)->
+	g�
+->
+	gp�t
+ = 
+p
+;
+
+779 
+	g�r
+ = 
+�ode_�th_cڡru�
+(
+�ode
+, 
+NULL
+);
+
+780 if(
+	g�r
+)
+
+782 
+f��ize
+();
+
+783  
+	g�r
+;
+
+787 (*
+	gnode
+)->
+	g�
+->
+	g�ags
+ = 
+FLAG_NODE_ULFS_UPTODATE
+;
+
+790 
+f��ize
+();
+
+791  
+	g�r
+;
+
+795 
+�r�_t
+
+
+796 
+	g�tfs_��m�_uƚk
+
+
+798 
+iou�r
+ * 
+	gu�r
+,
+
+799 
+node
+ * 
+	gd�
+,
+
+800 * 
+	g�me
+
+
+803 
+LOG_MSG
+("netfs_attempt_unlink");
+
+809 
+�r�_t
+
+
+810 
+	g�tfs_��m�_��me
+
+
+812 
+iou�r
+ * 
+	gu�r
+,
+
+813 
+node
+ * 
+	g�omd�
+,
+
+814 * 
+	g�om�me
+,
+
+815 
+node
+ * 
+	gtod�
+,
+
+816 * 
+	gt�ame
+,
+
+817 
+	gex�
+
+
+820 
+LOG_MSG
+("netfs_attempt_rename");
+
+823  
+	gEOPNOTSUPP
+;
+
+827 
+�r�_t
+
+
+828 
+	g�tfs_��m�_mkd�
+
+
+830 
+iou�r
+ * 
+	gu�r
+,
+
+831 
+node
+ * 
+	gd�
+,
+
+832 * 
+	g�me
+,
+
+833 
+mode_t
+ 
+	gmode
+
+
+836 
+LOG_MSG
+("netfs_attempt_mkdir");
+
+842 
+�r�_t
+
+
+843 
+	g�tfs_��m�_rmd�
+
+
+845 
+iou�r
+ * 
+	gu�r
+,
+
+846 
+node
+ * 
+	gd�
+,
+
+847 * 
+	g�me
+
+
+850 
+LOG_MSG
+("netfs_attempt_rmdir");
+
+856 
+�r�_t
+
+
+857 
+	g�tfs_��m�_chown
+
+
+859 
+iou�r
+ * 
+	g�ed
+,
+
+860 
+node
+ * 
+	gnode
+,
+
+861 
+uid_t
+ 
+	guid
+,
+
+862 
+uid_t
+ 
+	ggid
+
+
+865 
+LOG_MSG
+("netfs_attempt_chown");
+
+868  
+	gEOPNOTSUPP
+;
+
+872 
+�r�_t
+
+
+873 
+	g�tfs_��m�_chauth�
+
+
+875 
+iou�r
+ * 
+	g�ed
+,
+
+876 
+node
+ * 
+	gnode
+,
+
+877 
+uid_t
+ 
+	gauth�
+
+
+880 
+LOG_MSG
+("netfs_attempt_chauthor");
+
+883  
+	gEOPNOTSUPP
+;
+
+887 
+�r�_t
+
+
+888 
+	g�tfs_��m�_chmod
+
+
+890 
+iou�r
+ * 
+	gu�r
+,
+
+891 
+node
+ * 
+	gnode
+,
+
+892 
+mode_t
+ 
+	gmode
+
+
+895 
+LOG_MSG
+("netfs_attempt_chmod");
+
+898  
+	gEOPNOTSUPP
+;
+
+902 
+�r�_t
+
+
+903 
+	g�tfs_��m�_mksyml�k
+
+
+905 
+iou�r
+ * 
+	g�ed
+,
+
+906 
+node
+ * 
+	gnode
+,
+
+907 * 
+	g�me
+
+
+910 
+LOG_MSG
+("netfs_attempt_mksymlink");
+
+913  
+	gEOPNOTSUPP
+;
+
+917 
+�r�_t
+
+
+918 
+	g�tfs_��m�_mkdev
+
+
+920 
+iou�r
+ * 
+	g�ed
+,
+
+921 
+node
+ * 
+	gnode
+,
+
+922 
+mode_t
+ 
+	gty�
+,
+
+923 
+dev_t
+ 
+	g�dexes
+
+
+926 
+LOG_MSG
+("netfs_attempt_mkdev");
+
+929  
+	gEOPNOTSUPP
+;
+
+933 
+�r�_t
+
+
+934 
+	g�tfs_�t_�����
+
+
+936 
+iou�r
+ * 
+	g�ed
+,
+
+937 
+node
+ * 
+	gnode
+,
+
+938 * 
+	g�gz
+,
+
+939 
+size_t
+ 
+	g�g�n
+
+
+942 
+LOG_MSG
+("netfs_set_translator");
+
+945  
+	gEOPNOTSUPP
+;
+
+949 
+�r�_t
+
+
+950 
+	g�tfs_��m�_ch�ags
+
+
+952 
+iou�r
+ * 
+	g�ed
+,
+
+953 
+node
+ * 
+	gnode
+,
+
+954 
+	g�ags
+
+
+957 
+LOG_MSG
+("netfs_attempt_chflags");
+
+960  
+	gEOPNOTSUPP
+;
+
+964 
+�r�_t
+
+
+965 
+	g�tfs_��m�_�t_size
+
+
+967 
+iou�r
+ * 
+	g�ed
+,
+
+968 
+node
+ * 
+	gnode
+,
+
+969 
+loff_t
+ 
+	gsize
+
+
+972 
+LOG_MSG
+("netfs_attempt_set_size");
+
+975  
+	gEOPNOTSUPP
+;
+
+979 
+�r�_t
+
+
+980 
+	g�tfs_��m�_��fs
+
+
+982 
+iou�r
+ * 
+	g�ed
+,
+
+983 
+node
+ * 
+	gnode
+,
+
+984 
+fsys_��fsbuf_t
+ * 
+	g�
+
+
+987 
+LOG_MSG
+("netfs_attempt_statfs");
+
+990  
+	gEOPNOTSUPP
+;
+
+994 
+�r�_t
+
+
+995 
+	g�tfs_��m�_syncfs
+
+
+997 
+iou�r
+ * 
+	g�ed
+,
+
+998 
+	gwa�
+
+
+1001 
+LOG_MSG
+("netfs_attempt_syncfs");
+
+1008 
+�r�_t
+
+
+1009 
+	g�tfs_��m�_l�k
+
+
+1011 
+iou�r
+ * 
+	gu�r
+,
+
+1012 
+node
+ * 
+	gd�
+,
+
+1013 
+node
+ * 
+	gf�e
+,
+
+1014 * 
+	g�me
+,
+
+1015 
+	gex�
+
+
+1018 
+LOG_MSG
+("netfs_attempt_link");
+
+1021  
+	gEOPNOTSUPP
+;
+
+1025 
+�r�_t
+
+
+1026 
+	g�tfs_��m�_mkf�e
+
+
+1028 
+iou�r
+ * 
+	gu�r
+,
+
+1029 
+node
+ * 
+	gd�
+,
+
+1030 
+mode_t
+ 
+	gmode
+,
+
+1031 
+node
+ ** 
+	gnode
+
+
+1034 
+LOG_MSG
+("netfs_attempt_mkfile");
+
+1037 
+mu�x_u�ock
+(&
+d�
+->
+lock
+);
+
+1040  
+	gEOPNOTSUPP
+;
+
+1044 
+�r�_t
+
+
+1045 
+	g�tfs_��m�_�adl�k
+
+
+1047 
+iou�r
+ * 
+	gu�r
+,
+
+1048 
+node
+ * 
+	gnode
+,
+
+1049 * 
+	gbuf
+
+
+1052 
+LOG_MSG
+("netfs_attempt_readlink");
+
+1055  
+	gEOPNOTSUPP
+;
+
+1059 
+�r�_t
+
+
+1060 
+	g�tfs_��m�_�ad
+
+
+1062 
+iou�r
+ * 
+	g�ed
+,
+
+1063 
+node
+ * 
+	g�
+,
+
+1064 
+loff_t
+ 
+	goff�t
+,
+
+1065 
+size_t
+ * 
+	g�n
+,
+
+1066 * 
+	gd�a
+
+
+1069 
+LOG_MSG
+("netfs_attempt_read");
+
+1071 
+�r�_t
+ 
+	g�r
+ = 0;
+
+1074 if(
+	g�
+->
+	g�
+->
+	gp�t
+ =�
+MACH_PORT_NULL
+)
+
+1077 
+node_t
+ * 
+d�
+;
+
+1080 
+	g�r
+ = 
+n�che_node_lookup
+(
+�
+->
+�
+->
+�ode
+->
+d�
+, &
+d�
+);
+
+1083 
+as��
+(!
+�r
+);
+
+1086 
+mach_p�t_t
+ 
+	gp
+ = 
+f�e_�me_lookup_und�
+
+
+1087 (
+d�
+->
+�
+->
+p�t
+, 
+	g�
+->
+	g�
+->
+	g�ode
+->
+	g�me
+, 
+	gO_READ
+, 0);
+
+1090 
+�tfs_�ut
+(
+d�
+);
+
+1092 if(!
+	gp
+)
+
+1093  
+	gEBADF
+;
+
+1096 
+	g�
+->
+	g�
+->
+	gp�t
+ = 
+p
+;
+
+1100 
+	g�r
+ = 
+io_�ad
+(
+�
+->
+�
+->
+p�t
+, (**)&
+d�a
+, 
+�n
+, 
+off�t
+, *len);
+
+1103  
+	g�r
+;
+
+1107 
+�r�_t
+
+
+1108 
+	g�tfs_��m�_wr�e
+
+
+1110 
+iou�r
+ * 
+	g�ed
+,
+
+1111 
+node
+ * 
+	gnode
+,
+
+1112 
+loff_t
+ 
+	goff�t
+,
+
+1113 
+size_t
+ * 
+	g�n
+,
+
+1114 * 
+	gd�a
+
+
+1117 
+LOG_MSG
+("netfs_attempt_write");
+
+1124 
+	g�tfs_node_n�efs
+
+
+1126 
+node
+ * 
+	g�
+
+
+1130 
+node_de�roy
+(
+�
+);
+
+1135 
+	gma�
+
+
+1137 
+	g�gc
+,
+
+1138 ** 
+	g�gv
+
+
+1142 
+INIT_LOG
+();
+
+1143 
+LOG_MSG
+(">> Starting initialization...");
+
+1146 
+mach_p�t_t
+ 
+	gbo١�p_p�t
+;
+
+1148 
+�r�_t
+ 
+	g�r
+ = 0;
+
+1151 
+�gp_�r�
+(&
+�gp_��tup
+, 
+�gc
+, 
+�gv
+, 
+ARGP_IN_ORDER
+, 0, 0);
+
+1152 
+LOG_MSG
+("Command�ine�rguments�arsed.");
+
+1155 
+	g�r
+ = 
+node_���_ro�
+(&
+�tfs_ro�_node
+);
+
+1156 if(
+	g�r
+)
+
+1157 
+�r�
+(
+EXIT_FAILURE
+, 
+�r
+, "Failed�o create�he�oot�ode");
+
+1158 
+LOG_MSG
+("Root�ode created.");
+
+1161 
+�sk_g�_bo١�p_p�t
+(
+mach_�sk_�lf
+(), &
+bo١�p_p�t
+);
+
+1164 
+�tfs_��
+();
+
+1167 
+	gund�ly�g_node
+ = 
+�tfs_��tup
+(
+bo١�p_p�t
+, 
+O_READ
+);
+
+1168 
+LOG_MSG
+("netfs initialization complete.");
+
+1171 
+	g�r
+ = 
+node_��_ro�
+(
+�tfs_ro�_node
+);
+
+1172 if(
+	g�r
+)
+
+1173 
+�r�
+(
+EXIT_FAILURE
+, 
+�r
+, "Failed�o initialize�he�oot�ode");
+
+1174 
+LOG_MSG
+("Root�ode initialized.");
+
+1175 
+LOG_MSG
+("\tRoقod�add�ss: 0x%lX", ()
+�tfs_ro�_node
+);
+
+1178 
+	g�r
+ = 
+m�time_m�
+(0, 0, &
+m�time
+);
+
+1179 if(
+	g�r
+)
+
+1180 
+�r�
+(
+EXIT_FAILURE
+, 
+�r
+, "Failed�o map�he�ime");
+
+1181 
+LOG_MSG
+("Time mapped.");
+
+1184 
+n�che_��
+(
+n�che_size
+);
+
+1185 
+LOG_MSG
+("Cache initialized.");
+
+1188 
+	g�r
+ = 
+io_��
+(
+und�ly�g_node
+, &
+und�ly�g_node_��
+);
+
+1189 if(
+	g�r
+)
+
+1190 
+�r�
+(
+EXIT_FAILURE
+, 
+�r
+,
+
+1192 
+LOG_MSG
+("Stat information for undelying�ode obtained.");
+
+1195 
+	gfsid
+ = 
+g�pid
+();
+
+1198 
+	g�tfs_ro�_node
+->
+	g�_��
+ = 
+und�ly�g_node_��
+;
+
+1200 
+	g�tfs_ro�_node
+->
+	g�_��
+.
+	g�_�o
+ = 
+FILTERFS_ROOT_INODE
+;
+
+1201 
+	g�tfs_ro�_node
+->
+	g�_��
+.
+	g�_fsid
+ = 
+fsid
+;
+
+1202 
+	g�tfs_ro�_node
+->
+	g�_��
+.
+	g�_mode
+ = 
+S_IFDIR
+ | (
+und�ly�g_node_��
+.
+�_mode
+
+
+1203 & ~
+S_IFMT
+ & ~
+S_ITRANS
+);
+
+1205 
+	g�tfs_ro�_node
+->
+	g�_����ed
+ = 
+�tfs_ro�_node
+->
+�_��
+.
+�_mode
+;
+
+1209 if(!
+S_ISDIR
+(
+und�ly�g_node_��
+.
+�_mode
+))
+
+1212 if(
+	gund�ly�g_node_��
+.
+	g�_mode
+ & 
+	gS_IRUSR
+)
+
+1214 
+	g�tfs_ro�_node
+->
+	g�_��
+.
+	g�_mode
+ |�
+S_IXUSR
+;
+
+1216 if(
+	gund�ly�g_node_��
+.
+	g�_mode
+ & 
+	gS_IRGRP
+)
+
+1218 
+	g�tfs_ro�_node
+->
+	g�_��
+.
+	g�_mode
+ |�
+S_IXGRP
+;
+
+1220 if(
+	gund�ly�g_node_��
+.
+	g�_mode
+ & 
+	gS_IROTH
+)
+
+1222 
+	g�tfs_ro�_node
+->
+	g�_��
+.
+	g�_mode
+ |�
+S_IXOTH
+;
+
+1226 
+	gfsh�p_touch
+
+
+1227 (&
+	g�tfs_ro�_node
+->
+	g�_��
+, 
+	gTOUCH_ATIME
+ | 
+	gTOUCH_MTIME
+ | 
+	gTOUCH_CTIME
+,
+
+1228 
+	gm�time
+);
+
+1230 
+LOG_MSG
+(">> Initialization complete. Entering�etfs server�oop...");
+
+1234 
+�tfs_�rv�_lo�
+();
+
+	@filterfs.h
+
+26 #i�de�
+__FILTERFS_H__
+
+
+27 

+	#__FILTERFS_H__
+
+
+	)
+
+29 
+	~<�ddef.h
+>
+
+30 
+	~<�dlib.h
+>
+
+31 
+	~<�h�ads.h
+>
+
+32 
+	~<uni�d.h
+>
+
+33 
+	~<sys/mm�.h
+>
+
+34 
+	~<sys/ty�s.h
+>
+
+35 
+	~<sys/��.h
+>
+
+36 
+	~<sys/��fs.h
+>
+
+37 
+	~<sys/time.h
+>
+
+38 
+	~<hurd/ihash.h
+>
+
+39 
+	~<hurd/ioh�p.h
+>
+
+41 
+	~"lib.h
+"
+
+42 
+	~"node.h
+"
+
+48 

+	#FILTERFS_ROOT_INODE
+ 1
+
+	)
+
+55 
vީ��
+m��d_time_v�ue
+ * 
+m�time
+;
+
+58 

+mach_p�t_t
+ 
+und�ly�g_node
+;
+
+61 

+io_��buf_t
+ 
+und�ly�g_node_��
+;
+
+67 
+	sf��rfs_d�_��y
+
+
+69 * 
+	m�me
+;
+
+70 
+size_t
+ 
+	mhv
+;
+
+72 
+node
+ * 
+	mnode
+;
+
+75 
+��
+ 
+	m��
+;
+
+77 * 
+	msyml�k_�rg�
+;
+
+79 
+time_t
+ 
+	m��_time�amp
+;
+
+82 
+f��rfs_d�
+ * 
+	md�
+;
+
+88 
+f��rfs_d�_��y
+ * 
+	m�xt
+, ** 
+	m�lf_p
+;
+
+92 
+f��rfs_d�_��y
+ * 
+	m�d�ed_�xt
+, ** 
+	m�d�ed_�lf_p
+;
+
+95 
+time_t
+ 
+	m�me_time�amp
+;
+
+98 
+hurd_ihash_lo�_t
+ 
+	m�ode_lo�
+;
+
+101 
+	mn��
+ : 1;
+
+104 
+	mv�id
+ : 1;
+
+108 
+	sf��rfs_d�
+
+
+111 
+size_t
+ 
+	mnum_���s
+;
+
+116 
+size_t
+ 
+	mnum_live_���s
+;
+
+119 
+f��rfs_d�_��y
+ ** 
+	mh�b�
+;
+
+120 
+size_t
+ 
+	mh�b�_�n
+;
+
+126 
+f��rfs_d�_��y
+ * 
+	m�d�ed
+;
+
+129 
+node
+ * 
+	mnode
+;
+
+132 
+f��rfs
+ * 
+	mfs
+;
+
+135 
+time_t
+ 
+	m�me_time�amp
+;
+
+138 
+hurd_ihash_lo�_t
+ 
+	m�ode_lo�
+;
+
+145 
+time_t
+ 
+	mbuld_��_ba�_�amp
+;
+
+149 
+	mbulk_��_cou�_f��_h�f
+;
+
+154 
+	mbulk_��_cou�_�c�d_h�f
+;
+
+158 
+	sf��rfs
+
+
+161 
+node
+ * 
+	mro�
+;
+
+165 
+�o_t
+ 
+	m�xt_�ode
+;
+
+168 
+	mfsid
+;
+
+171 
+hurd_ihash
+ 
+	m�ode_m�p�gs
+;
+
+174 
+��_lock_t
+ 
+	m�ode_m�p�gs_lock
+;
+
+181 
+�r�_t
+
+
+182 
+	g�tfs_��m�_���_f�e
+
+
+184 
+iou�r
+ * 
+	gu�r
+,
+
+185 
+node
+ * 
+	gd�
+,
+
+186 * 
+	g�me
+,
+
+187 
+mode_t
+ 
+	gmode
+,
+
+188 
+node
+ ** 
+	gnode
+
+
+193 
+�r�_t
+
+
+194 
+	g�tfs_check_ݒ_�rmissi�s
+
+
+196 
+iou�r
+ * 
+	gu�r
+,
+
+197 
+node
+ * 
+	g�
+,
+
+198 
+	g�ags
+,
+
+199 
+	g�wnode
+
+
+203 
+�r�_t
+
+
+204 
+	g�tfs_��m�_utimes
+
+
+206 
+iou�r
+ * 
+	g�ed
+,
+
+207 
+node
+ * 
+	gnode
+,
+
+208 
+time�ec
+ * 
+	g�ime
+,
+
+209 
+time�ec
+ * 
+	gmtime
+
+
+213 
+�r�_t
+
+
+214 
+	g�tfs_�p�t_ac�ss
+
+
+216 
+iou�r
+ * 
+	g�ed
+,
+
+217 
+node
+ * 
+	g�
+,
+
+218 * 
+	gty�s
+
+
+222 
+�r�_t
+
+
+223 
+	g�tfs_v�id�e_��
+
+
+225 
+node
+ * 
+	g�
+,
+
+226 
+iou�r
+ * 
+	g�ed
+
+
+230 
+�r�_t
+
+
+231 
+	g�tfs_��m�_sync
+
+
+233 
+iou�r
+ * 
+	g�ed
+,
+
+234 
+node
+ * 
+	gnode
+,
+
+235 
+	gwa�
+
+
+239 
+�r�_t
+
+
+240 
+	g�tfs_g�_d��ts
+
+
+242 
+iou�r
+ * 
+	g�ed
+,
+
+243 
+node
+ * 
+	gd�
+,
+
+244 
+	gf��_��y
+,
+
+245 
+	gnum_���s
+,
+
+246 ** 
+	gd�a
+,
+
+247 
+mach_msg_ty�_numb�_t
+ * 
+	gd�a_�n
+,
+
+248 
+vm_size_t
+ 
+	gmax_d�a_�n
+,
+
+249 * 
+	gd�a_���s
+
+
+253 
+�r�_t
+
+
+254 
+	g�tfs_��m�_lookup
+
+
+256 
+iou�r
+ * 
+	gu�r
+,
+
+257 
+node
+ * 
+	gd�
+,
+
+258 * 
+	g�me
+,
+
+259 
+node
+ ** 
+	gnode
+
+
+263 
+�r�_t
+
+
+264 
+	g�tfs_��m�_uƚk
+
+
+266 
+iou�r
+ * 
+	gu�r
+,
+
+267 
+node
+ * 
+	gd�
+,
+
+268 * 
+	g�me
+
+
+272 
+�r�_t
+
+
+273 
+	g�tfs_��m�_��me
+
+
+275 
+iou�r
+ * 
+	gu�r
+,
+
+276 
+node
+ * 
+	g�omd�
+,
+
+277 * 
+	g�om�me
+,
+
+278 
+node
+ * 
+	gtod�
+,
+
+279 * 
+	gt�ame
+,
+
+280 
+	gex�
+
+
+284 
+�r�_t
+
+
+285 
+	g�tfs_��m�_mkd�
+
+
+287 
+iou�r
+ * 
+	gu�r
+,
+
+288 
+node
+ * 
+	gd�
+,
+
+289 * 
+	g�me
+,
+
+290 
+mode_t
+ 
+	gmode
+
+
+294 
+�r�_t
+
+
+295 
+	g�tfs_��m�_rmd�
+
+
+297 
+iou�r
+ * 
+	gu�r
+,
+
+298 
+node
+ * 
+	gd�
+,
+
+299 * 
+	g�me
+
+
+303 
+�r�_t
+
+
+304 
+	g�tfs_��m�_chown
+
+
+306 
+iou�r
+ * 
+	g�ed
+,
+
+307 
+node
+ * 
+	gnode
+,
+
+308 
+uid_t
+ 
+	guid
+,
+
+309 
+uid_t
+ 
+	ggid
+
+
+313 
+�r�_t
+
+
+314 
+	g�tfs_��m�_chauth�
+
+
+316 
+iou�r
+ * 
+	g�ed
+,
+
+317 
+node
+ * 
+	gnode
+,
+
+318 
+uid_t
+ 
+	gauth�
+
+
+322 
+�r�_t
+
+
+323 
+	g�tfs_��m�_chmod
+
+
+325 
+iou�r
+ * 
+	gu�r
+,
+
+326 
+node
+ * 
+	gnode
+,
+
+327 
+mode_t
+ 
+	gmode
+
+
+331 
+�r�_t
+
+
+332 
+	g�tfs_��m�_mksyml�k
+
+
+334 
+iou�r
+ * 
+	g�ed
+,
+
+335 
+node
+ * 
+	gnode
+,
+
+336 * 
+	g�me
+
+
+340 
+�r�_t
+
+
+341 
+	g�tfs_��m�_mkdev
+
+
+343 
+iou�r
+ * 
+	g�ed
+,
+
+344 
+node
+ * 
+	gnode
+,
+
+345 
+mode_t
+ 
+	gty�
+,
+
+346 
+dev_t
+ 
+	g�dexes
+
+
+350 
+�r�_t
+
+
+351 
+	g�tfs_�t_�����
+
+
+353 
+iou�r
+ * 
+	g�ed
+,
+
+354 
+node
+ * 
+	gnode
+,
+
+355 * 
+	g�gz
+,
+
+356 
+size_t
+ 
+	g�g�n
+
+
+360 
+�r�_t
+
+
+361 
+	g�tfs_��m�_ch�ags
+
+
+363 
+iou�r
+ * 
+	g�ed
+,
+
+364 
+node
+ * 
+	gnode
+,
+
+365 
+	g�ags
+
+
+369 
+�r�_t
+
+
+370 
+	g�tfs_��m�_�t_size
+
+
+372 
+iou�r
+ * 
+	g�ed
+,
+
+373 
+node
+ * 
+	gnode
+,
+
+374 
+loff_t
+ 
+	gsize
+
+
+378 
+�r�_t
+
+
+379 
+	g�tfs_��m�_��fs
+
+
+381 
+iou�r
+ * 
+	g�ed
+,
+
+382 
+node
+ * 
+	gnode
+,
+
+383 
+fsys_��fsbuf_t
+ * 
+	g�
+
+
+387 
+�r�_t
+
+
+388 
+	g�tfs_��m�_syncfs
+
+
+390 
+iou�r
+ * 
+	g�ed
+,
+
+391 
+	gwa�
+
+
+395 
+�r�_t
+
+
+396 
+	g�tfs_��m�_l�k
+
+
+398 
+iou�r
+ * 
+	gu�r
+,
+
+399 
+node
+ * 
+	gd�
+,
+
+400 
+node
+ * 
+	gf�e
+,
+
+401 * 
+	g�me
+,
+
+402 
+	gex�
+
+
+406 
+�r�_t
+
+
+407 
+	g�tfs_��m�_mkf�e
+
+
+409 
+iou�r
+ * 
+	gu�r
+,
+
+410 
+node
+ * 
+	gd�
+,
+
+411 
+mode_t
+ 
+	gmode
+,
+
+412 
+node
+ ** 
+	gnode
+
+
+416 
+�r�_t
+
+
+417 
+	g�tfs_��m�_�adl�k
+
+
+419 
+iou�r
+ * 
+	gu�r
+,
+
+420 
+node
+ * 
+	gnode
+,
+
+421 * 
+	gbuf
+
+
+425 
+�r�_t
+
+
+426 
+	g�tfs_��m�_�ad
+
+
+428 
+iou�r
+ * 
+	g�ed
+,
+
+429 
+node
+ * 
+	g�
+,
+
+430 
+loff_t
+ 
+	goff�t
+,
+
+431 
+size_t
+ * 
+	g�n
+,
+
+432 * 
+	gd�a
+
+
+436 
+�r�_t
+
+
+437 
+	g�tfs_��m�_wr�e
+
+
+439 
+iou�r
+ * 
+	g�ed
+,
+
+440 
+node
+ * 
+	gnode
+,
+
+441 
+loff_t
+ 
+	goff�t
+,
+
+442 
+size_t
+ * 
+	g�n
+,
+
+443 * 
+	gd�a
+
+
+448 
+	g�tfs_node_n�efs
+
+
+450 
+node
+ * 
+	g�
+
+
+	@lib.c
+
+28 

+	#_GNU_SOURCE
+ 1
+
+	)
+
+30 
+	~<sys/mm�.h
+>
+
+32 
+	~"lib.h
+"
+
+33 
+	~"debug.h
+"
+
+39 
+�r�_t
+
+
+40 
+	gd�_���s_g�
+
+
+42 
+f�e_t
+ 
+	gd�
+,
+
+43 ** 
+	gd��t_d�a
+,
+
+45 
+size_t
+ * 
+	gd��t_d�a_size
+,
+
+46 
+d��t
+ *** 
+	gd��t_li�
+
+
+50 
+�r�_t
+ 
+	g�r
+ = 0;
+
+53 * 
+	gd�a
+;
+
+56 
+size_t
+ 
+	gd�a_size
+;
+
+59 
+	g���s_num
+;
+
+62 
+	g�r
+ = 
+d�_�add�
+(
+d�
+, &
+d�a
+, &
+d�a_size
+, 0, -1, 0, &
+���s_num
+);
+
+63 if(
+	g�r
+)
+
+64  
+	g�r
+;
+
+67 
+d��t
+ ** 
+	gli�
+;
+
+71 
+	gli�
+ = 
+m�loc
+((
+d��t
+ *�* (
+���s_num
+ + 1));
+
+74 if(!
+	gli�
+)
+
+77 
+munm�
+(
+d�a
+, 
+d�a_size
+);
+
+80  
+	gENOMEM
+;
+
+84 
+d��t
+ * 
+	gdp
+;
+
+86 
+	gi
+;
+
+91 
+	gi
+ = 0, 
+	gdp
+ = (
+d��t
+ *)
+d�a
+;
+
+92 
+	gi
+ < 
+	g���s_num
+;
+
+93 ++
+	gi
+, 
+	gdp
+ = (
+d��t
+ *)((*)
+dp
+ + dp->
+d_���
+))
+
+95 *(
+li�
+ + 
+i
+��
+dp
+;
+
+98 *(
+	gli�
+ + 
+	gi
+��
+NULL
+;
+
+101 *
+	gd��t_d�a
+ = 
+d�a
+;
+
+102 *
+	gd��t_d�a_size
+ = 
+d�a_size
+;
+
+103 *
+	gd��t_li�
+ = 
+li�
+;
+
+106  
+	g�r
+;
+
+110 
+�r�_t
+
+
+111 
+	gf�e_lookup
+
+
+113 
+f�e_t
+ 
+	gd�
+,
+
+114 * 
+	g�me
+,
+
+115 
+	g�ags0
+,
+
+116 
+	g�ags1
+,
+
+117 
+	gmode
+,
+
+118 
+f�e_t
+ * 
+	gp�t
+,
+
+119 
+io_��buf_t
+ * 
+	g��
+
+
+122 
+�r�_t
+ 
+	g�r
+ = 0;
+
+125 
+f�e_t
+ 
+	gp
+;
+
+128 
+io_��buf_t
+ 
+	gs
+;
+
+131 
+f�e_t
+
+
+132 
+	gdo_f�e_lookup
+
+
+134 
+f�e_t
+ 
+	gd�
+,
+
+135 * 
+	g�me
+,
+
+136 
+	g�ags
+,
+
+137 
+	gmode
+
+
+141 
+f�e_t
+ 
+	gp
+;
+
+144 if(
+	gd�
+ !�
+MACH_PORT_NULL
+)
+
+146 
+p
+ = 
+f�e_�me_lookup_und�
+(
+d�
+, 
+�me
+, 
+�ags
+, 
+mode
+);
+
+149 
+	gp
+ = 
+f�e_�me_lookup
+(
+�me
+, 
+�ags
+, 
+mode
+);
+
+152  
+	gp
+;
+
+156 
+	gp
+ = 
+do_f�e_lookup
+(
+d�
+, 
+�me
+, 
+�ags0
+, 
+mode
+);
+
+159 if(
+	gp
+ =�
+MACH_PORT_NULL
+)
+
+161 
+p
+ = 
+do_f�e_lookup
+(
+d�
+, 
+�me
+, 
+�ags1
+, 
+mode
+);
+
+164 if(
+	gp
+ !�
+MACH_PORT_NULL
+)
+
+167 if(
+��
+)
+
+170 
+�r
+ = 
+io_��
+(
+p
+, &
+s
+);
+
+171 if(
+	g�r
+)
+
+172 
+PORT_DEALLOC
+(
+p
+);
+
+177 
+	g�r
+ = 
+��o
+;
+
+180 if(!
+	g�r
+)
+
+183 *
+	gp�t
+ = 
+p
+;
+
+186 if(
+	g��
+)
+
+187 *
+	g��
+ = 
+s
+;
+
+191  
+	g�r
+;
+
+	@lib.h
+
+26 #i�de�
+__LIB_H__
+
+
+27 

+	#__LIB_H__
+
+
+	)
+
+30 

+	#__USE_FILE_OFFSET64
+
+
+	)
+
+32 
+	~<hurd.h
+>
+
+33 
+	~<d��t.h
+>
+
+34 
+	~<�ddef.h
+>
+
+40 

+	#DIRENT_ALIGN
+ 4
+
+	)
+
+43 

+	#DIRENT_NAME_OFFS
+ 
+	`off�tof
+(
+d��t
+, 
+d_�me
+)
+
+	)
+
+47 

+	#DIRENT_LEN
+(
+�me_�n
+)\
+
+48 ((
+DIRENT_NAME_OFFS
+ + (
+�me_�n
+�+ 1 + 
+DIRENT_ALIGN
+ - 1) &\
+
+49 ~(
+DIRENT_ALIGN
+ - 1))
+
+	)
+
+52 

+	#PORT_DEALLOC
+(
+p
+�(
+	`mach_p�t_d��o��
+(
+	`mach_�sk_�lf
+(), (p)))
+
+	)
+
+58 
+�r�_t
+
+
+59 
+	gd�_���s_g�
+
+
+61 
+f�e_t
+ 
+	gd�
+,
+
+62 ** 
+	gd��t_d�a
+,
+
+64 
+size_t
+ * 
+	gd��t_d�a_size
+,
+
+65 
+d��t
+ *** 
+	gd��t_li�
+
+
+70 
+�r�_t
+
+
+71 
+	gf�e_lookup
+
+
+73 
+f�e_t
+ 
+	gd�
+,
+
+74 * 
+	g�me
+,
+
+75 
+	g�ags0
+,
+
+76 
+	g�ags1
+,
+
+77 
+	gmode
+,
+
+78 
+f�e_t
+ * 
+	gp�t
+,
+
+79 
+io_��buf_t
+ * 
+	g��
+
+
+	@lnode.c
+
+28 

+	#_GNU_SOURCE
+
+
+	)
+
+30 
+	~"�ode.h
+"
+
+31 
+	~"debug.h
+"
+
+38 
+	g�ode_�f_add
+
+
+40 
+�ode_t
+ * 
+	gnode
+
+
+44 ++
+	gnode
+->
+	g��n�s
+;
+
+50 
+	g�ode_�f_�move
+
+
+52 
+�ode_t
+ * 
+	gnode
+
+
+56 
+as��
+(
+node
+->
+��n�s
+);
+
+59 --
+	gnode
+->
+	g��n�s
+;
+
+62 if(
+	gnode
+->
+	g��n�s
+ == 0)
+
+65 
+�ode_un���l
+(
+node
+);
+
+66 
+�ode_de�roy
+(
+node
+);
+
+70 
+mu�x_u�ock
+(&
+node
+->
+lock
+);
+
+75 
+�r�_t
+
+
+76 
+	g�ode_���
+
+
+78 * 
+	g�me
+,
+
+79 
+�ode_t
+ ** 
+	gnode
+
+
+83 
+�ode_t
+ * 
+	gnode_�w
+ = 
+m�loc
+((lnode_t));
+
+86 if(!
+	gnode_�w
+)
+
+89  
+	gENOMEM
+;
+
+93 * 
+	g�me_�
+ = 
+NULL
+;
+
+96 if(
+	g�me
+)
+
+99 
+	g�me_�
+ = 
+�rdup
+(
+�me
+);
+
+102 if(!
+	g�me_�
+)
+
+105 
+�
+(
+node_�w
+);
+
+108  
+	gENOMEM
+;
+
+113 
+mem�t
+(
+node_�w
+, 0, (
+�ode_t
+));
+
+114 
+	gnode_�w
+->
+	g�me
+ = 
+�me_�
+;
+
+115 
+	gnode_�w
+->
+	g�me_�n
+ = (
+�me_�
+�? (
+���
+(name_cp)) : (0);
+
+118 
+	gnode_�w
+->
+	g��n�s
+ = 1;
+
+121 
+mu�x_��
+(&
+node_�w
+->
+lock
+);
+
+122 
+mu�x_lock
+(&
+node_�w
+->
+lock
+);
+
+125 *
+	gnode
+ = 
+node_�w
+;
+
+133 
+	g�ode_de�roy
+
+
+135 
+�ode_t
+ * 
+	gnode
+
+
+139 
+�
+(
+node
+->
+�me
+);
+
+142 
+�
+(
+node
+);
+
+147 
+�r�_t
+
+
+148 
+	g�ode_�th_cڡru�
+
+
+150 
+�ode_t
+ * 
+	gnode
+,
+
+151 ** 
+	g�th
+
+
+154 
+�r�_t
+ 
+	g�r
+ = 0;
+
+157 * 
+	gp
+;
+
+160 
+	gp_�n
+ = 0;
+
+163 
+�ode_t
+ * 
+	gn
+;
+
+166 
+	gn
+ = 
+node
+;� &&�->
+	gd�
+;� = 
+n
+->
+d�
+)
+
+172 
+p_�n
+ +�
+n
+->
+�me_�n
+ + 1;
+
+176 
+	gp_�n
+ +�
+���
+(
+n
+->
+�th
+) + 1;
+
+179 
+	gp
+ = 
+m�loc
+(
+p_�n
+ * ());
+
+180 if(!
+	gp
+)
+
+181 
+	g�r
+ = 
+ENOMEM
+;
+
+186 
+	gp
+[--
+p_�n
+] = 0;
+
+189 
+	gn
+ = 
+node
+;� &&�->
+	gd�
+;� = 
+n
+->
+d�
+)
+
+192 
+p_�n
+ -�
+n
+->
+�me_�n
+;
+
+195 
+���y
+(
+p
+ + 
+p_�n
+, 
+n
+->
+�me
+,�->
+�me_�n
+);
+
+202 
+	gp
+[--
+p_�n
+] = '/';
+
+207 
+���y
+(
+p
+, 
+n
+->
+�th
+, 
+���
+(n->path));
+
+210 if(
+	gnode
+->
+	g�th
+)
+
+211 
+�
+(
+node
+->
+�th
+);
+
+214 
+	gnode
+->
+	g�th
+ = 
+p
+;
+
+217 if(
+	g�th
+)
+
+218 *
+	g�th
+ = 
+p
+;
+
+222  
+	g�r
+;
+
+226 
+�r�_t
+
+
+227 
+	g�ode_g�
+
+
+229 
+�ode_t
+ * 
+	gd�
+,
+
+230 * 
+	g�me
+,
+
+231 
+�ode_t
+ ** 
+	gnode
+
+
+234 
+�r�_t
+ 
+	g�r
+ = 0;
+
+237 
+�ode_t
+ * 
+	gn
+;
+
+240 
+	gn
+ = 
+d�
+->
+���s
+;� && (
+�rcmp
+(
+n
+->
+�me
+,�ame�!�0);� =�->
+�xt
+);
+
+243 if(
+	gn
+)
+
+246 
+mu�x_lock
+(&
+n
+->
+lock
+);
+
+249 
+�ode_�f_add
+(
+n
+);
+
+252 *
+	gnode
+ = 
+n
+;
+
+255 
+	g�r
+ = 
+ENOENT
+;
+
+258  
+	g�r
+;
+
+264 
+	g�ode_���l
+
+
+266 
+�ode_t
+ * 
+	gd�
+,
+
+267 
+�ode_t
+ * 
+	gnode
+
+
+271 
+	gnode
+->
+	g�xt
+ = 
+d�
+->
+���s
+;
+
+272 
+	gnode
+->
+	g�evp
+ = &
+d�
+->
+���s
+;
+
+273 if(
+	gd�
+->
+	g���s
+)
+
+274 
+	gd�
+->
+	g���s
+->
+	g�evp
+ = &
+node
+->
+�xt
+;
+
+276 
+	gd�
+->
+	g���s
+ = 
+node
+;
+
+279 
+�ode_�f_add
+(
+d�
+);
+
+282 
+	gnode
+->
+	gd�
+ = 
+d�
+;
+
+288 
+	g�ode_un���l
+
+
+290 
+�ode_t
+ * 
+	gnode
+
+
+294 
+�ode_�f_�move
+(
+node
+->
+d�
+);
+
+298 *
+	gnode
+->
+	g�evp
+ = 
+node
+->
+�xt
+;
+
+302 if(
+	gnode
+->
+	g�xt
+)
+
+303 
+	gnode
+->
+	g�xt
+->
+	g�evp
+ = &
+node
+->
+�xt
+;
+
+	@lnode.h
+
+26 #i�de�
+__LNODE_H__
+
+
+27 

+	#__LNODE_H__
+
+
+	)
+
+30 
+	~<�r�.h
+>
+
+31 
+	~<hurd/�tfs.h
+>
+
+36 
+node
+ 
+	tnode_t
+;
+
+39 
+	s�ode
+
+
+42 * 
+	m�me
+;
+
+46 
+size_t
+ 
+	m�me_�n
+;
+
+49 * 
+	m�th
+;
+
+52 
+	m�ags
+;
+
+55 
+	m��n�s
+;
+
+58 
+node_t
+ * 
+	mnode
+;
+
+61 
+�ode
+ * 
+	m�xt
+, **
+	m�evp
+;
+
+64 
+�ode
+ * 
+	md�
+;
+
+67 
+�ode
+ * 
+	m���s
+;
+
+70 
+mu�x
+ 
+	mlock
+;
+
+73 
+�ode
+ 
+	t�ode_t
+;
+
+80 
+	g�ode_�f_add
+
+
+82 
+�ode_t
+ * 
+	gnode
+
+
+88 
+	g�ode_�f_�move
+
+
+90 
+�ode_t
+ * 
+	gnode
+
+
+95 
+�r�_t
+
+
+96 
+	g�ode_���
+
+
+98 * 
+	g�me
+,
+
+99 
+�ode_t
+ ** 
+	gnode
+
+
+104 
+	g�ode_de�roy
+
+
+106 
+�ode_t
+ * 
+	gnode
+
+
+111 
+�r�_t
+
+
+112 
+	g�ode_�th_cڡru�
+
+
+114 
+�ode_t
+ * 
+	gnode
+,
+
+115 ** 
+	g�th
+
+
+119 
+�r�_t
+
+
+120 
+	g�ode_g�
+
+
+122 
+�ode_t
+ * 
+	gd�
+,
+
+123 * 
+	g�me
+,
+
+124 
+�ode_t
+ ** 
+	gnode
+
+
+130 
+	g�ode_���l
+
+
+132 
+�ode_t
+ * 
+	gd�
+,
+
+133 
+�ode_t
+ * 
+	gnode
+
+
+138 
+	g�ode_un���l
+
+
+140 
+�ode_t
+ * 
+	gnode
+
+
+	@ncache.c
+
+28 

+	#_GNU_SOURCE
+ 1
+
+	)
+
+30 
+	~"n�che.h
+"
+
+36 
+n�che_t
+ 
+	gn�che
+;
+
+39 
+	gn�che_size
+ = 
+NCACHE_SIZE
+;
+
+46 
+	gn�che_��
+
+
+48 
+	gsize_max
+
+
+52 
+	gn�che
+.
+	gmru
+ = 
+n�che
+.
+�u
+ = 
+NULL
+;
+
+55 
+	gn�che
+.
+	gsize_max
+ = 
+size_max
+;
+
+58 
+	gn�che
+.
+	gsize_cu��t
+ = 0;
+
+61 
+mu�x_��
+(&
+n�che
+.
+lock
+);
+
+66 
+�r�_t
+
+
+67 
+	gn�che_node_lookup
+
+
+69 
+�ode_t
+ * 
+	g�ode
+,
+
+70 
+node_t
+ ** 
+	gnode
+
+
+73 
+�r�_t
+ 
+	g�r
+ = 0;
+
+76 
+node_t
+ * 
+	gn
+ = 
+�ode
+->
+node
+;
+
+79 if(
+	gn
+ !�
+NULL
+)
+
+82 
+�tfs_�ef
+(
+n
+);
+
+87 
+	g�r
+ = 
+node_���
+(
+�ode
+, &
+n
+);
+
+91 if(!
+	g�r
+)
+
+94 
+mu�x_lock
+(&
+n
+->
+lock
+);
+
+97 *
+	gnode
+ = 
+n
+;
+
+101  
+	g�r
+;
+
+107 
+	gn�che_node_�move
+
+
+109 
+node_t
+ * 
+	gnode
+
+
+114 
+Êode
+ * 
+	g�
+ = 
+node
+->
+�
+;
+
+117 if(
+	g�
+->
+	gn�che_�xt
+)
+
+119 
+	g�
+->
+	gn�che_�xt
+->�->
+	gn�che_�ev
+ = 
+�
+->
+n�che_�ev
+;
+
+121 if(
+	g�
+->
+	gn�che_�ev
+)
+
+123 
+	g�
+->
+	gn�che_�ev
+->�->
+	gn�che_�xt
+ = 
+�
+->
+n�che_�xt
+;
+
+126 if(
+	gn�che
+.
+	gmru
+ =�
+node
+)
+
+128 
+n�che
+.
+mru
+ = 
+�
+->
+n�che_�xt
+;
+
+130 if(
+	gn�che
+.
+	g�u
+ =�
+node
+)
+
+132 
+n�che
+.
+�u
+ = 
+�
+->
+n�che_�ev
+;
+
+135 
+	g�
+->
+	gn�che_�xt
+ = 
+�
+->
+n�che_�ev
+ = 
+NULL
+;
+
+138 --
+	gn�che
+.
+	gsize_cu��t
+;
+
+143 
+	$n�che_��t
+()
+
+146 
+node_t
+ * 
+node
+;
+
+149 
+	`mu�x_lock
+(&
+n�che
+.
+lock
+);
+
+152 
+node
+ = 
+n�che
+.
+mru
+;�od�!�
+NULL
+; 
+	`n�che_node_�move
+(node),�ode =�cache.mru);
+
+155 
+	`mu�x_u�ock
+(&
+n�che
+.
+lock
+);
+
+156 
+	}
+}
+
+160 
+	gn�che_node_add
+
+
+162 
+node_t
+ * 
+	gnode
+
+
+166 
+mu�x_lock
+(&
+n�che
+.
+lock
+);
+
+169 if((
+	gn�che
+.
+	gsize_max
+ > 0�|| (n�che.
+	gsize_cu��t
+ > 0))
+
+172 if(
+	gn�che
+.
+	gmru
+ !�
+node
+)
+
+175 if((
+node
+->
+�
+->
+n�che_�xt
+ !�
+NULL
+�&& (node->�->
+n�che_�ev
+ != NULL))
+
+177 
+n�che_node_�move
+(
+node
+);
+
+180 
+�tfs_�ef
+(
+node
+);
+
+183 
+	gnode
+->
+	g�
+->
+	gn�che_�xt
+ = 
+n�che
+.
+mru
+;
+
+184 
+	gnode
+->
+	g�
+->
+	gn�che_�ev
+ = 
+NULL
+;
+
+187 if(
+	gn�che
+.
+	gmru
+ !�
+NULL
+)
+
+188 
+n�che
+.
+mru
+->
+�
+->
+n�che_�ev
+ = 
+node
+;
+
+191 if(
+	gn�che
+.
+	g�u
+ =�
+NULL
+)
+
+192 
+n�che
+.
+�u
+ = 
+node
+;
+
+195 
+	gn�che
+.
+	gmru
+ = 
+node
+;
+
+198 ++
+	gn�che
+.
+	gsize_cu��t
+;
+
+203 
+node_t
+ * 
+	g�d_�u
+;
+
+206 
+	g�d_�u
+ = 
+n�che
+.
+�u
+;
+
+207 
+	gn�che
+.
+	gsize_cu��t
+ >��che.
+	gsize_max
+;
+
+208 
+	g�d_�u
+ = 
+n�che
+.
+�u
+
+
+212 
+n�che_node_�move
+(
+�d_�u
+);
+
+215 
+�tfs_Ėe
+(
+�d_�u
+);
+
+219 
+mu�x_u�ock
+(&
+n�che
+.
+lock
+);
+
+	@ncache.h
+
+26 #i�de�
+__NCACHE_H__
+
+
+27 

+	#__NCACHE_H__
+
+
+	)
+
+30 
+	~<�r�.h
+>
+
+31 
+	~<hurd/�tfs.h
+>
+
+33 
+	~"node.h
+"
+
+39 

+	#NCACHE_SIZE
+ 256
+
+	)
+
+44 
+	sn�che
+
+
+47 
+node_t
+ * 
+	mmru
+;
+
+50 
+node_t
+ * 
+	m�u
+;
+
+53 
+	msize_max
+;
+
+56 
+	msize_cu��t
+;
+
+59 
+mu�x
+ 
+	mlock
+;
+
+62 
+n�che
+ 
+	tn�che_t
+;
+
+68 

+�che_size
+;
+
+75 
+	gn�che_��
+
+
+77 
+	gsize_max
+
+
+82 
+�r�_t
+
+
+83 
+	gn�che_node_lookup
+
+
+85 
+�ode_t
+ * 
+	g�ode
+,
+
+86 
+node_t
+ ** 
+	gnode
+
+
+91 
+n�che_��t
+();
+
+95 
+	gn�che_node_add
+
+
+97 
+node_t
+ * 
+	gnode
+
+
+	@node.c
+
+28 

+	#_GNU_SOURCE
+ 1
+
+	)
+
+30 
+	~<�dlib.h
+>
+
+31 
+	~<f��.h
+>
+
+32 
+	~<sys/��.h
+>
+
+33 
+	~<sys/mm�.h
+>
+
+34 
+	~<�dio.h
+>
+
+36 
+	~"debug.h
+"
+
+37 
+	~"node.h
+"
+
+38 
+	~"�ti�s.h
+"
+
+39 
+	~"lib.h
+"
+
+40 
+	~"f��rfs.h
+"
+
+46 
+mu�x
+ 
+	gulfs_lock
+ = 
+MUTEX_INITIALIZER
+;
+
+52 
+�r�_t
+
+
+53 
+	gnode_���
+
+
+55 
+�ode_t
+ * 
+	g�ode
+,
+
+56 
+node_t
+ ** 
+	gnode
+
+
+59 
+�r�_t
+ 
+	g�r
+ = 0;
+
+62 
+Êode_t
+ * 
+	gÊode_�w
+ = 
+m�loc
+((netnode_t));
+
+65 if(
+	gÊode_�w
+ =�
+NULL
+)
+
+66 
+�r
+ = 
+ENOMEM
+;
+
+70 
+node_t
+ * 
+	gnode_�w
+ = 
+�tfs_make_node
+(
+Êode_�w
+);
+
+73 if(
+	gnode_�w
+ =�
+NULL
+)
+
+76 
+�r
+ = 
+ENOMEM
+;
+
+79 
+�
+(
+Êode_�w
+);
+
+82  
+	g�r
+;
+
+86 
+	g�ode
+->
+	gnode
+ = 
+node_�w
+;
+
+87 
+�ode_�f_add
+(
+�ode
+);
+
+90 
+	gnode_�w
+->
+	g�
+->
+	g�ode
+ = 
+�ode
+;
+
+91 
+	gnode_�w
+->
+	g�
+->
+	g�ags
+ = 0;
+
+92 
+	gnode_�w
+->
+	g�
+->
+	gn�che_�xt
+ = 
+node_�w
+->
+�
+->
+n�che_�ev
+ = 
+NULL
+;
+
+95 *
+	gnode
+ = 
+node_�w
+;
+
+99  
+	g�r
+;
+
+105 
+	gnode_de�roy
+
+
+107 
+node_t
+ * 
+	g�
+
+
+111 
+as��
+(!
+�
+->
+�
+->
+n�che_�xt
+ || !�->�->
+n�che_�ev
+);
+
+114 
+PORT_DEALLOC
+(
+�
+->
+�
+->
+p�t
+);
+
+117 
+mu�x_lock
+(&
+�
+->
+�
+->
+�ode
+->
+lock
+);
+
+120 
+	g�
+->
+	g�
+->
+	g�ode
+->
+	gnode
+ = 
+NULL
+;
+
+123 
+�ode_�f_�move
+(
+�
+->
+�
+->
+�ode
+);
+
+126 
+�
+(
+�
+->
+�
+);
+
+127 
+�
+(
+�
+);
+
+131 
+�r�_t
+
+
+132 
+	gnode_���_ro�
+
+
+134 
+node_t
+ ** 
+	gro�_node
+
+
+138 
+�ode_t
+ * 
+	g�ode
+;
+
+139 
+�r�_t
+ 
+	g�r
+ = 
+�ode_���
+(
+NULL
+, &
+�ode
+);
+
+142 if(
+	g�r
+)
+
+143  
+	g�r
+;
+
+146 
+node_t
+ * 
+	gnode
+;
+
+147 
+	g�r
+ = 
+node_���
+(
+�ode
+, &
+node
+);
+
+150 if(
+	g�r
+)
+
+153 
+�ode_de�roy
+(
+�ode
+);
+
+156  
+	g�r
+;
+
+160 
+mu�x_u�ock
+(&
+�ode
+->
+lock
+);
+
+163 *
+	gro�_node
+ = 
+node
+;
+
+166  
+	g�r
+;
+
+170 
+�r�_t
+
+
+171 
+	gnode_��_ro�
+
+
+173 
+node_t
+ * 
+	gnode
+
+
+176 
+�r�_t
+ 
+	g�r
+ = 0;
+
+179 
+mu�x_lock
+(&
+ulfs_lock
+);
+
+182 
+	gnode
+->
+	g�
+->
+	gp�t
+ = 
+f�e_�me_lookup
+(
+d�
+, 
+O_READ
+ | 
+O_DIRECTORY
+, 0);
+
+185 if(
+	gnode
+->
+	g�
+->
+	gp�t
+ =�
+MACH_PORT_NULL
+)
+
+188 
+�r
+ = 
+��o
+;
+
+189 
+LOG_MSG
+("node_��_ro�: Could�� o��th�p܈f� %s.", 
+d�
+);
+
+192 
+mu�x_u�ock
+(&
+ulfs_lock
+);
+
+193  
+	g�r
+;
+
+196 
+LOG_MSG
+("node_��_ro�: P܈f� %�ݒed suc�ssfu�y.", 
+d�
+);
+
+197 
+LOG_MSG
+("\tP�t: 0x%lX", ()
+node
+->
+�
+->
+p�t
+);
+
+200 
+	g�r
+ = 
+io_��
+(
+node
+->
+�
+->
+p�t
+, &node->
+�_��
+);
+
+201 if(
+	g�r
+)
+
+204 
+PORT_DEALLOC
+(
+node
+->
+�
+->
+p�t
+);
+
+206 
+LOG_MSG
+("node_init_root: Could�ot stat�he�oot�ode.");
+
+209 
+mu�x_u�ock
+(&
+ulfs_lock
+);
+
+210  
+	g�r
+;
+
+214 
+	gnode
+->
+	g�
+->
+	g�ode
+->
+	g�th
+ = 
+�rdup
+(
+d�
+);
+
+215 if(!
+	gnode
+->
+	g�
+->
+	g�ode
+->
+	g�th
+)
+
+218 
+PORT_DEALLOC
+(
+node
+->
+�
+->
+p�t
+);
+
+221 
+mu�x_u�ock
+(&
+ulfs_lock
+);
+
+223 
+LOG_MSG
+("node_init_root: Could�ot strdup�he directory.");
+
+224  
+	gENOMEM
+;
+
+228 * 
+	gp
+ = 
+d�
+ + 
+���
+(dir);
+
+231 ; 
+	gp
+ >�
+d�
+; --p)
+
+234 if(*
+	gp
+ == '/')
+
+237 if(
+p
+ > 
+d�
+)
+
+240 if(*(
+p
+ - 1) == '\\')
+
+245 ++
+	gp
+;
+
+252 
+LOG_MSG
+("node_��_ro�: Th��m�o�roقod�i�%s.", 
+p
+);
+
+255 
+	gnode
+->
+	g�
+->
+	g�ode
+->
+	g�me
+ = 
+�rdup
+(
+p
+);
+
+257 if(!
+	gnode
+->
+	g�
+->
+	g�ode
+->
+	g�me
+)
+
+260 
+�
+(
+node
+->
+�
+->
+�ode
+->
+�th
+);
+
+261 
+PORT_DEALLOC
+(
+node
+->
+�
+->
+p�t
+);
+
+264 
+mu�x_u�ock
+(&
+ulfs_lock
+);
+
+266 
+LOG_MSG
+("node_init_root: Could�ot strdup�he�ame of�he�oot�ode.");
+
+267  
+	gENOMEM
+;
+
+271 
+	gnode
+->
+	g�
+->
+	g�ode
+->
+	g�me_�n
+ = 
+���
+(
+p
+);
+
+274 
+mu�x_u�ock
+(&
+ulfs_lock
+);
+
+277  
+	g�r
+;
+
+282 
+	gnode_���s_�
+
+
+284 
+node_d��t_t
+ * 
+	gd��ts
+
+
+288 
+node_d��t_t
+ * 
+	gd��t
+, * 
+	gd��t_�xt
+;
+
+291 
+	gd��t
+ = 
+d��ts
+; d��t; d����
+d��t_�xt
+)
+
+294 
+d��t_�xt
+ = 
+d��t
+->
+�xt
+;
+
+297 
+�
+(
+d��t
+->dirent);
+
+300 
+�
+(
+d��t
+);
+
+305 
+�r�_t
+
+
+306 
+	gnode_���s_g�
+
+
+308 
+node_t
+ * 
+	gnode
+,
+
+309 
+node_d��t_t
+ ** 
+	gd��ts
+
+
+312 
+�r�_t
+ 
+	g�r
+ = 0;
+
+315 * 
+	g�th_to_node
+ = 
+node
+->
+�
+->
+�ode
+->
+�th
+;
+
+318 
+	g��m_���s_cou�
+ = 0;
+
+321 
+size_t
+ 
+	g�ݔty_�n
+ = (
+�ݔty
+�? (
+���
+(property)) : (0);
+
+324 
+size_t
+ 
+	g�ݔty_��m_�n
+ = 
+���
+(
+PROPERTY_PARAM
+);
+
+327 * 
+	gfu�_�me
+ = 
+NULL
+, * 
+	gcmd
+ = NULL;
+
+330 
+size_t
+ 
+	gfu�_�me_size
+ = 1, 
+	gcmd_size
+ = 1;
+
+333 if(
+	g�ݔty_�n
+ != 0)
+
+336 * 
+occu���
+ = 
+�r�r
+(
+�ݔty
+, 
+PROPERTY_PARAM
+);
+
+339 ; 
+	goccu���
+;
+
+340 
+	goccu���
+ = 
+�r�r
+(
+occu���
+ + 1, 
+PROPERTY_PARAM
+),
+
+341 ++
+	g��m_���s_cou�
+);
+
+344 
+	gfu�_�me
+ = 
+m�loc
+(
+fu�_�me_size
+ * 
+STRING_CHUNK
+);
+
+345 if(!
+	gfu�_�me
+)
+
+346  
+	gENOMEM
+;
+
+348 
+	gcmd
+ = 
+m�loc
+(
+cmd_size
+ * 
+STRING_CHUNK
+);
+
+349 if(!
+	gcmd
+)
+
+351 
+�
+(
+fu�_�me
+);
+
+352  
+	gENOMEM
+;
+
+357 
+size_t
+ 
+	g�th�n
+ = 
+���
+(
+�th_to_node
+);
+
+362 
+	gcheck_�ݔty
+
+
+364 cڡ * 
+	g�me
+
+
+368 if(!
+	g�ݔty
+)
+
+373 
+	g�r
+ = 0;
+
+376 
+size_t
+ 
+	gfu�_�me_�n
+ = 
+�th�n
+ + 1 + 
+���
+(
+�me
+) + 1;
+
+379 
+	gchunks
+ = 
+fu�_�me_size
+;
+
+380 ; 
+	gfu�_�me_�n
+ > 
+chunks
+ * 
+	gSTRING_CHUNK
+; ++
+	gchunks
+);
+
+383 if(
+	gchunks
+ > 
+	gfu�_�me_size
+)
+
+386 
+�
+(
+fu�_�me
+);
+
+389 
+	gfu�_�me
+ = 
+m�loc
+(
+chunks
+ * 
+STRING_CHUNK
+);
+
+390 if(!
+	gfu�_�me
+)
+
+392 
+	g�r
+ = 
+ENOMEM
+;
+
+393 
+�
+(
+cmd
+);
+
+398 
+	gfu�_�me_size
+ = 
+chunks
+;
+
+402 
+	gfu�_�me
+[0] = 0;
+
+405 
+�r�y
+(
+fu�_�me
+, 
+�th_to_node
+);
+
+406 
+�r�t
+(
+fu�_�me
+, "/");
+
+407 
+�r�t
+(
+fu�_�me
+, 
+�me
+);
+
+412 
+size_t
+ 
+	gsz
+ = 
+�ݔty_�n
+ + (
+���
+(
+fu�_�me
+�- 
+�ݔty_��m_�n
+)
+
+413 * 
+��m_���s_cou�
+;
+
+416 
+	gchunks
+ = 
+cmd_size
+; 
+	gsz
+ > 
+chunks
+ * 
+	gSTRING_CHUNK
+; ++chunks);
+
+419 if(
+	gchunks
+ > 
+	gcmd_size
+)
+
+422 
+�
+(
+cmd
+);
+
+425 
+	gcmd
+ = 
+m�loc
+(
+chunks
+ * 
+STRING_CHUNK
+);
+
+426 if(!
+	gcmd
+)
+
+428 
+	g�r
+ = 
+ENOMEM
+;
+
+429 
+�
+(
+fu�_�me
+);
+
+435 
+	gcmd_size
+ = 
+chunks
+;
+
+439 
+	gcmd
+[0] = 0;
+
+442 * 
+	gp
+ = 
+�r�r
+(
+�ݔty
+, 
+PROPERTY_PARAM
+);
+
+445 * 
+	g��p
+ = 
+�ݔty
+;
+
+448 ; 
+	gp
+;� = 
+�r�r
+(
+��p
+, 
+PROPERTY_PARAM
+))
+
+451 
+���t
+(
+cmd
+, 
+��p
+, 
+p
+ -�ropp);
+
+454 
+�r�t
+(
+cmd
+, 
+fu�_�me
+);
+
+459 
+	g��p
+ = 
+p
+ + 
+�ݔty_��m_�n
+;
+
+465 
+�r�t
+(
+cmd
+, 
+��p
+);
+
+470 
+	gxcode
+ = 
+WEXITSTATUS
+(
+sy�em
+(
+cmd
+));
+
+473  
+	gxcode
+;
+
+477 
+d��t
+ ** 
+	gd��t_li�
+, **
+	gd��t
+;
+
+480 
+node_d��t_t
+ * 
+	gnode_d��t_li�
+ = 
+NULL
+;
+
+483 
+size_t
+ 
+	gd��t_d�a_size
+;
+
+486 * 
+	gd��t_d�a
+;
+
+489 
+	g�r
+ = 
+d�_���s_g�
+
+
+490 (
+node
+->
+�
+->
+p�t
+, &
+	gd��t_d�a
+, &
+	gd��t_d�a_size
+, &
+	gd��t_li�
+);
+
+491 if(
+	g�r
+)
+
+493  
+	g�r
+;
+
+497 
+node_d��t_t
+ * 
+	gnode_d��t_�w
+;
+
+500 
+d��t
+ * 
+	gd��t_�w
+;
+
+505 * 
+	g�me
+;
+
+508 
+size_t
+ 
+	g�me_�n
+;
+
+511 
+size_t
+ 
+	gsize
+;
+
+514 
+	ggood
+;
+
+517 
+	gd��t
+ = 
+d��t_li�
+; *dirent; ++dirent)
+
+520 
+	g�me
+ = &((*
+d��t
+)->
+d_�me
+[0]);
+
+523 if((
+�rcmp
+(
+�me
+, ".") == 0) || (strcmp(name, "..") == 0))
+
+527 
+	ggood
+ = 
+check_�ݔty
+(
+�me
+);
+
+528 if(
+	g�r
+)
+
+532 if(
+	ggood
+ != 0)
+
+536 
+	g�me_�n
+ = 
+���
+(
+�me
+);
+
+539 
+	gsize
+ = 
+DIRENT_LEN
+(
+�me_�n
+);
+
+542 
+	gnode_d��t_�w
+ = 
+m�loc
+((
+node_d��t_t
+));
+
+543 if(!
+	gnode_d��t_�w
+)
+
+545 
+	g�r
+ = 
+ENOMEM
+;
+
+550 
+	gd��t_�w
+ = 
+m�loc
+(
+size
+);
+
+551 if(!
+	gd��t_�w
+)
+
+553 
+�
+(
+node_d��t_�w
+);
+
+554 
+	g�r
+ = 
+ENOMEM
+;
+
+559 
+	gd��t_�w
+->
+	gd_�o
+ = (*
+d��t
+)->
+d_�o
+;
+
+560 
+	gd��t_�w
+->
+	gd_ty�
+ = (*
+d��t
+)->
+d_ty�
+;
+
+561 
+	gd��t_�w
+->
+	gd_���
+ = 
+size
+;
+
+562 
+�r�y
+((*)
+d��t_�w
+ + 
+DIRENT_NAME_OFFS
+, 
+�me
+);
+
+565 
+	gnode_d��t_�w
+->
+	gd��t
+ = 
+d��t_�w
+;
+
+566 
+	gnode_d��t_�w
+->
+	g�xt
+ = 
+node_d��t_li�
+;
+
+567 
+	gnode_d��t_li�
+ = 
+node_d��t_�w
+;
+
+571 if(
+	g�r
+)
+
+573 
+node_���s_�
+(
+node_d��t_li�
+);
+
+576 *
+	gd��ts
+ = 
+node_d��t_li�
+;
+
+579 
+�
+(
+d��t_li�
+);
+
+582 
+munm�
+(
+d��t_d�a
+, 
+d��t_d�a_size
+);
+
+585 if(
+	gfu�_�me
+)
+
+586 
+�
+(
+fu�_�me
+);
+
+587 if(
+	gcmd
+)
+
+588 
+�
+(
+cmd
+);
+
+591  
+	g�r
+;
+
+596 
+�r�_t
+
+
+597 
+	gnode_upd�e
+
+
+599 
+node_t
+ * 
+	gnode
+
+
+602 
+�r�_t
+ 
+	g�r
+ = 0;
+
+605 * 
+	g�th
+;
+
+608 
+io_��buf_t
+ 
+	g��
+;
+
+611 
+f�e_t
+ 
+	gp�t
+;
+
+614 if(
+NODE_IS_ROOT
+(
+node
+�|| (
+	gnode
+->
+	g�
+->
+	g�ags
+ & 
+	gFLAG_NODE_ULFS_FIXED
+))
+
+616  
+	g�r
+;
+
+619 
+mu�x_lock
+(&
+�tfs_ro�_node
+->
+lock
+);
+
+622 
+	g�r
+ = 
+�ode_�th_cڡru�
+(
+node
+->
+�
+->
+�ode
+, &
+�th
+);
+
+623 if(
+	g�r
+)
+
+625 
+mu�x_u�ock
+(&
+�tfs_ro�_node
+->
+lock
+);
+
+626  
+	g�r
+;
+
+630 if(
+	gnode
+->
+	g�
+->
+	gp�t
+)
+
+631 
+PORT_DEALLOC
+(
+node
+->
+�
+->
+p�t
+);
+
+634 
+	g�r
+ = 
+f�e_lookup
+
+
+636 
+�tfs_ro�_node
+->
+�
+->
+p�t
+, 
+	g�th
+, 
+	gO_READ
+ | 
+	gO_NOTRANS
+, O_NOTRANS,
+
+637 0, &
+	gp�t
+, &
+	g��
+
+
+639 if(
+	g�r
+)
+
+641 
+	gnode
+->
+	g�
+->
+	gp�t
+ = 
+MACH_PORT_NULL
+;
+
+642 
+	g�r
+ = 0;
+
+643  
+	g�r
+;
+
+649 (
+	g��
+.
+	g�_�o
+ =�
+und�ly�g_node_��
+.
+�_�o
+)
+
+650 && (
+��
+.
+�_fsid
+ =�
+und�ly�g_node_��
+.st_fsid)
+
+653 
+�r
+ = 
+ELOOP
+;
+
+657 
+PORT_DEALLOC
+(
+p�t
+);
+
+660 
+	g�r
+ = 
+f�e_lookup
+
+
+661 (
+�tfs_ro�_node
+->
+�
+->
+p�t
+, 
+	g�th
+, 
+	gO_READ
+, 0, 0, &
+	gp�t
+, &
+	g��
+);
+
+665 if(
+	g�r
+)
+
+667 
+	gp�t
+ = 
+MACH_PORT_NULL
+;
+
+670 
+	gnode
+->
+	g�
+->
+	gp�t
+ = 
+p�t
+;
+
+674 
+	gnode
+->
+	g�
+->
+	g�ags
+ &�~
+FLAG_NODE_INVALIDATE
+;
+
+675 
+	gnode
+->
+	g�
+->
+	g�ags
+ |�
+FLAG_NODE_ULFS_UPTODATE
+;
+
+678 
+mu�x_u�ock
+(&
+�tfs_ro�_node
+->
+lock
+);
+
+681  
+	g�r
+;
+
+685 
+�r�_t
+
+
+686 
+	gnode_g�_size
+
+
+688 
+node_t
+ * 
+	gd�
+,
+
+689 
+OFFSET_T
+ * 
+	goff
+
+
+692 
+�r�_t
+ 
+	g�r
+ = 0;
+
+695 
+size_t
+ 
+	gsize
+ = 0;
+
+704 
+node_d��t_t
+ * 
+	gd��t_cu��t
+ = 
+NULL
+;
+
+707 
+node_d��t_t
+ * 
+	gd��t_li�
+ = 
+NULL
+;
+
+714 
+	gbump_size
+
+
+716 cڡ * 
+	g�me
+
+
+720 
+	gsize
+ +�
+DIRENT_LEN
+(
+���
+(
+�me
+));
+
+727 
+	g�r
+ = 
+node_���s_g�
+(
+d�
+, &
+d��t_li�
+);
+
+728 if(
+	g�r
+)
+
+729  
+	g�r
+;
+
+754 
+	gd��t_cu��t
+ = 
+d��t_li�
+ ; dirent_current;
+
+755 
+	gd��t_cu��t
+ = 
+d��t_cu��t
+->
+�xt
+
+
+757 
+bump_size
+(
+d��t_cu��t
+->
+d��t
+->
+d_�me
+);
+
+760 
+node_���s_�
+(
+d��t_li�
+);
+
+763 *
+	goff
+ = 
+size
+;
+
+768 
+�r�_t
+
+
+769 
+	gnode_uƚk_f�e
+
+
+771 
+node_t
+ * 
+	gd�
+,
+
+772 * 
+	g�me
+
+
+775 
+�r�_t
+ 
+	g�r
+ = 0;
+
+778 
+mach_p�t_t
+ 
+	gp
+;
+
+781 
+io_��buf_t
+ 
+	g��
+;
+
+784 if(
+	gd�
+->
+	g�
+->
+	gp�t
+ =�
+MACH_PORT_NULL
+)
+
+786  
+ENOENT
+;
+
+789 
+	g�r
+ = 
+f�e_lookup
+(
+d�
+->
+�
+->
+p�t
+, 
+�me
+, 
+O_NOTRANS
+, O_NOTRANS, 0, &
+p
+, &
+��
+);
+
+790 if(
+	g�r
+)
+
+791  
+	g�r
+;
+
+794 
+PORT_DEALLOC
+(
+p
+);
+
+797 
+	g�r
+ = 
+d�_uƚk
+(
+d�
+->
+�
+->
+p�t
+, 
+�me
+);
+
+798 if(
+	g�r
+)
+
+799  
+	g�r
+;
+
+801  
+	g�r
+;
+
+	@node.h
+
+26 #i�de�
+__NODE_H__
+
+
+27 

+	#__NODE_H__
+
+
+	)
+
+30 
+	~<�r�.h
+>
+
+31 
+	~<sys/��.h
+>
+
+32 
+	~<hurd/�tfs.h
+>
+
+34 
+	~"�ode.h
+"
+
+40 

+	#NODE_IS_ROOT
+(
+n
+�((�)->
+�
+->
+�ode
+->
+d�
+�? (0�: (1))
+
+	)
+
+43 

+	#FLAG_NODE_ULFS_FIXED
+ 0x00000001
+
+	)
+
+44 

+	#FLAG_NODE_INVALIDATE
+ 0x00000002
+
+	)
+
+45 

+	#FLAG_NODE_ULFS_UPTODATE
+ 0x00000004
+
+	)
+
+48 #ifde�
+__USE_FILE_OFFSET64
+
+
+49 

+	#OFFSET_T
+ 
+__off64_t
+
+
+	)
+
+51 

+	#OFFSET_T
+ 
+__off_t
+
+
+	)
+
+56 

+	#STRING_CHUNK
+ 256
+
+	)
+
+61 
+	sÊode
+
+
+64 
+�ode_t
+ * 
+	m�ode
+;
+
+67 
+	m�ags
+;
+
+70 
+f�e_t
+ 
+	mp�t
+;
+
+73 
+node_t
+ * 
+	mn�che_�ev
+, * 
+	mn�che_�xt
+;
+
+76 
+Êode
+ 
+	tÊode_t
+;
+
+79 
+	snode_d��t
+
+
+82 
+d��t
+ * 
+	md��t
+;
+
+85 
+node_d��t
+ * 
+	m�xt
+;
+
+88 
+node_d��t
+ 
+	tnode_d��t_t
+;
+
+94 

+mu�x
+ 
+ulfs_lock
+;
+
+100 
+�r�_t
+
+
+101 
+	gnode_���
+
+
+103 
+�ode_t
+ * 
+	g�ode
+,
+
+104 
+node_t
+ ** 
+	gnode
+
+
+110 
+	gnode_de�roy
+
+
+112 
+node_t
+ * 
+	g�
+
+
+116 
+�r�_t
+
+
+117 
+	gnode_���_ro�
+
+
+119 
+node_t
+ ** 
+	gro�_node
+
+
+123 
+�r�_t
+
+
+124 
+	gnode_��_ro�
+
+
+126 
+node_t
+ * 
+	gnode
+
+
+131 
+	gnode_���s_�
+
+
+133 
+node_d��t_t
+ * 
+	gd��ts
+
+
+137 
+�r�_t
+
+
+138 
+	gnode_���s_g�
+
+
+140 
+node_t
+ * 
+	gnode
+,
+
+141 
+node_d��t_t
+ ** 
+	gd��ts
+
+
+146 
+�r�_t
+
+
+147 
+	gnode_upd�e
+
+
+149 
+node_t
+ * 
+	gnode
+
+
+153 
+�r�_t
+
+
+154 
+	gnode_g�_size
+
+
+156 
+node_t
+ * 
+	gd�
+,
+
+157 
+OFFSET_T
+ * 
+	goff
+
+
+161 
+�r�_t
+
+
+162 
+	gnode_uƚk_f�e
+
+
+164 
+node_t
+ * 
+	gd�
+,
+
+165 * 
+	g�me
+
+
+	@options.c
+
+28 

+	#_GNU_SOURCE
+ 1
+
+	)
+
+30 
+	~<�gp.h
+>
+
+31 
+	~<�r�.h
+>
+
+33 
+	~"debug.h
+"
+
+34 
+	~"�ti�s.h
+"
+
+35 
+	~"n�che.h
+"
+
+36 
+	~"node.h
+"
+
+42 

+	#ARGS_DOC
+ "DIR"
+
+	)
+
+43 

+	#DOC
+ "Show�th�cڋ��o�DIR f���d�cc�d�g��PROPERTY.\
+ DIR i�n� s�cif�d, ~/ i�assumed."
+
+	)
+
+51 
+�r�_t
+
+
+52 
+	g�gp_�r�_comm�_�ti�s
+
+
+54 
+	gkey
+,
+
+55 * 
+	g�g
+,
+
+56 
+�gp_��e
+ * 
+	g��e
+
+
+61 
+�r�_t
+
+
+62 
+	g�gp_�r�_��tup_�ti�s
+
+
+64 
+	gkey
+,
+
+65 * 
+	g�g
+,
+
+66 
+�gp_��e
+ * 
+	g��e
+
+
+77 
+	g�rs�g_��tup_�ti�s_f�ished
+;
+
+80 cڡ 
+�gp_�ti�
+ 
+	g�gp_comm�_�ti�s
+[] =
+
+82 {
+OPT_LONG_CACHE_SIZE
+, 
+OPT_CACHE_SIZE
+, "SIZE", 0,
+
+84 {
+OPT_LONG_PROPERTY
+, 
+OPT_PROPERTY
+, "PROPERTY", 0,
+
+89 cڡ 
+�gp_�ti�
+ 
+	g�gp_��tup_�ti�s
+[] =
+
+95 cڡ 
+�gp
+ 
+	g�gp_�r�r_comm�_�ti�s
+ =
+
+96 {
+�gp_comm�_�ti�s
+, 
+�gp_�r�_comm�_�ti�s
+, 0, 0, 0};
+
+99 cڡ 
+�gp
+ 
+	g�gp_�r�r_��tup_�ti�s
+ =
+
+100 {
+�gp_��tup_�ti�s
+, 
+�gp_�r�_��tup_�ti�s
+, 0, 0, 0};
+
+103 cڡ 
+�gp_ch�d
+ 
+	g�gp_ch�d�n_ru�ime
+[] =
+
+105 {&
+�gp_�r�r_comm�_�ti�s
+},
+
+106 {&
+�tfs_�d_ru�ime_�gp
+},
+
+111 cڡ 
+�gp_ch�d
+ 
+	g�gp_ch�d�n_��tup
+[] =
+
+113 {&
+�gp_�r�r_��tup_�ti�s
+},
+
+114 {&
+�gp_�r�r_comm�_�ti�s
+},
+
+115 {&
+�tfs_�d_��tup_�gp
+},
+
+120 cڡ * 
+	g�gp_�og�m_v�si�
+ = "0.0";
+
+123 
+�gp
+ 
+	g�gp_ru�ime
+ =
+
+124 {0, 0, 0, 0, 
+�gp_ch�d�n_ru�ime
+};
+
+127 
+�gp
+ 
+	g�gp_��tup
+ =
+
+128 {0, 0, 
+ARGS_DOC
+, 
+DOC
+, 
+�gp_ch�d�n_��tup
+};
+
+131 * 
+	g�ݔty
+ = 
+NULL
+;
+
+134 * 
+	gd�
+ = 
+NULL
+;
+
+141 
+�r�_t
+
+
+142 
+	g�gp_�r�_comm�_�ti�s
+
+
+144 
+	gkey
+,
+
+145 * 
+	g�g
+,
+
+146 
+�gp_��e
+ * 
+	g��e
+
+
+149 
+�r�_t
+ 
+	g�r
+ = 0;
+
+152 
+	gkey
+)
+
+154 
+	gOPT_CACHE_SIZE
+:
+
+157 
+n�che_size
+ = 
+���
+(
+�g
+, 
+NULL
+, 10);
+
+161 
+	gOPT_PROPERTY
+:
+
+164 
+�ݔty
+ = 
+�rdup
+(
+�g
+);
+
+165 if(!
+	g�ݔty
+)
+
+166 
+�r�
+(
+EXIT_FAILURE
+, 
+ENOMEM
+, "Could�ot strdup�he�roperty");
+
+170 
+	gARGP_KEY_ARG
+:
+
+173 
+d�
+ = 
+�rdup
+(
+�g
+);
+
+174 if(!
+	gd�
+)
+
+175 
+�r�
+(
+EXIT_FAILURE
+, 
+ENOMEM
+, "argp_parse_common_options: "
+
+179 
+	gi
+ = 
+���
+(
+d�
+) - 1;
+
+184 if((
+	gd�
+[
+i
+] == '/') && (i != 0))
+
+186 
+d�
+[
+i
+] = 0;
+
+188 
+LOG_MSG
+("�gp_�r�_comm�_�ti�s: F��r�g�h�d�e��y %s.", 
+d�
+);
+
+192 
+	gARGP_KEY_END
+:
+
+195 if(!
+�rs�g_��tup_�ti�s_f�ished
+)
+
+198 
+n�che_��t
+();
+
+201 if(!
+	gd�
+)
+
+207 
+	gd�
+ = "/var/tmp";
+
+211 
+	g�rs�g_��tup_�ti�s_f�ished
+ = 1;
+
+222 
+�r
+ = 
+ARGP_ERR_UNKNOWN
+;
+
+227  
+	g�r
+;
+
+232 
+�r�_t
+
+
+233 
+	g�gp_�r�_��tup_�ti�s
+
+
+235 
+	gkey
+,
+
+236 * 
+	g�g
+,
+
+237 
+�gp_��e
+ * 
+	g��e
+
+
+241 
+�r�_t
+ 
+	g�r
+ = 0;
+
+243 
+	gkey
+)
+
+247 
+�r
+ = 
+ARGP_ERR_UNKNOWN
+;
+
+253  
+	g�r
+;
+
+	@options.h
+
+26 #i�de�
+__OPTIONS_H__
+
+
+27 

+	#__OPTIONS_H__
+
+
+	)
+
+32 

+	#OPT_CACHE_SIZE
+ 'c'
+
+	)
+
+34 

+	#OPT_PROPERTY
+ 'p'
+
+	)
+
+37 

+	#OPT_LONG_CACHE_SIZE
+ "�che-size"
+
+	)
+
+38 

+	#OPT_LONG_PROPERTY
+ "�ݔty"
+
+	)
+
+41 

+	#OPT_LONG
+(
+o
+�"--"
+	)
+o
+
+44 

+	#PROPERTY_PARAM
+ "{}"
+
+	)
+
+50 

+�gp
+ 
+�gp_��tup
+;
+
+53 

+�gp
+ 
+�gp_ru�ime
+;
+
+56 

+n�che_size
+;
+
+59 
* 
+�ݔty
+;
+
+62 
* 
+d�
+;
+
+	@/usr/include/dirent.h
+
+58 #i�de�
+_DIRENT_H_
+
+
+59 

+	#_DIRENT_H_
+
+
+	)
+
+65 
+	~<_ty�s.h
+>
+
+66 
+	~<sys/d��t.h
+>
+
+68 
+	g_��d�
+;
+
+72 
+	m__dd_fd
+;
+
+73 
+	m__dd_loc
+;
+
+74 
+	m__dd_size
+;
+
+75 *
+	m__dd_buf
+;
+
+76 
+	m__dd_�n
+;
+
+77 
+	m__dd_�ek
+;
+
+78 
+	m__dd_�w�d
+;
+
+79 
+	m__dd_�ags
+;
+
+80 
+__d�w�_�h�ad_mu�x_t
+ 
+	m__dd_lock
+;
+
+81 
+_��d�
+ *
+	m__dd_td
+;
+
+82 } 
+	tDIR
+;
+
+84 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+86 

+	#DIRBLKSIZ
+ 1024
+
+	)
+
+88 

+	#d�fd
+(
+d�p
+�((d�p)->
+__dd_fd
+)
+
+	)
+
+91 

+	#DTF_HIDEW
+ 0x0001
+
+	)
+
+92 

+	#DTF_NODUP
+ 0x0002
+
+	)
+
+93 

+	#DTF_REWIND
+ 0x0004
+
+	)
+
+94 

+	#__DTF_READALL
+ 0x0008
+
+	)
+
+98 #i�de�
+KERNEL
+
+
+100 
+	~<sys/cdefs.h
+>
+
+102 
+	g__BEGIN_DECLS
+
+
+103 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+104 
+	$�phas�t
+(cڡ *, cڡ *�
+	`__DARWIN_INODE64
+(
+�phas�t
+);
+
+106 
+	$�o�d�
+(
+DIR
+ *�
+	`__DARWIN_ALIAS
+(
+�o�d�
+);
+
+107 #i�!
+	`def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+108 
+	`g�d����s
+(, *, , *);
+
+110 
+DIR
+ *
+	$ݒd�
+(cڡ *�
+	`__DARWIN_ALIAS_I
+(
+ݒd�
+);
+
+111 #i�!
+	`def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+112 
+DIR
+ *
+	$__ݒd�2
+(cڡ *, �
+	`__DARWIN_ALIAS_I
+(
+__ݒd�2
+);
+
+114 
+d��t
+ *
+	$�add�
+(
+DIR
+ *�
+	`__DARWIN_INODE64
+(
+�add�
+);
+
+115 
+	$�add�_r
+(
+DIR
+ *, 
+d��t
+ *, d���**�
+	`__DARWIN_INODE64
+(
+�add�_r
+);
+
+116 
+	$�w�dd�
+(
+DIR
+ *�
+	`__DARWIN_ALIAS_I
+(
+�w�dd�
+);
+
+117 #i�!
+	`def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+118 
+	`s�nd�
+(cڡ *, 
+d��t
+ ***,
+
+119 (*)(
+d��t
+ *), (*)(cڡ *, cڡ *)�
+	`__DARWIN_INODE64
+(
+s�nd�
+);
+
+121 
+	$�ekd�
+(
+DIR
+ *, �
+	`__DARWIN_ALIAS_I
+(
+�ekd�
+);
+
+122 
+	$��d�
+(
+DIR
+ *�
+	`__DARWIN_ALIAS_I
+(
+��d�
+);
+
+123 
+__END_DECLS
+
+
+	@/usr/include/fcntl.h
+
+23 
+	~<sys/f��.h
+>
+
+	@/usr/include/stddef.h
+
+61 #i�!
+def�ed
+(
+__STDDEF_H__
+)
+
+63 #i�!
+def�ed
+(
+__�ed_wch�_t
+�&& !def�ed(
+__�ed_size_t
+) \
+
+64 && !
+def�ed
+(
+__�ed_�rdiff_t
+�&& !def�ed(
+__�ed_NULL
+) \
+
+65 && !
+	$def�ed
+(
+__�ed_w�t_t
+)
+
+66 

+	#__STDDEF_H__
+
+
+	)
+
+69 
+	~<_ty�s.h
+>
+
+71 #i�
+	`def�ed
+(
+__STDDEF_H__
+�|| def�ed(
+__�ed_�rdiff_t
+)
+
+72 #i�de�
+_PTRDIFF_T
+
+
+73 

+	#_PTRDIFF_T
+
+
+	)
+
+74 
+__d�w�_�rdiff_t
+ 
+	t�rdiff_t
+;
+
+78 #i�
+	`def�ed
+(
+__STDDEF_H__
+�|| def�ed(
+__�ed_size_t
+)
+
+79 #i�def 
+_SIZE_T
+
+
+80 

+	#_SIZE_T
+
+
+	)
+
+83 
+__d�w�_size_t
+ 
+	tsize_t
+;
+
+87 #i�
+	`def�ed
+(
+__STDDEF_H__
+�|| def�ed(
+__�ed_wch�_t
+)
+
+88 #i�def 
+__�lu�lus
+
+
+89 #i�def 
+_WCHAR_T
+
+
+90 

+	#_WCHAR_T
+
+
+	)
+
+91 
+__d�w�_wch�_t
+ 
+	twch�_t
+;
+
+96 #i�(
+	`def�ed
+(
+__STDDEF_H__
+�&& !def�ed(
+_ANSI_SOURCE
+�&& (!def�ed(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+))) \
+
+97 || 
+	$def�ed
+(
+__�ed_w�t_t
+)
+
+98 #i�def 
+_WINT_T
+
+
+99 

+	#_WINT_T
+
+
+	)
+
+100 
+__d�w�_w�t_t
+ 
+	tw�t_t
+;
+
+104 #i�
+	`def�ed
+(
+__STDDEF_H__
+�|| def�ed(
+__�ed_NULL
+)
+
+105 #i�de�
+NULL
+
+
+106 

+	#NULL
+ 
+__DARWIN_NULL
+
+
+	)
+
+110 #ifde�
+__STDDEF_H__
+
+
+111 #i�
+	`def�ed
+(
+__GNUC__
+�&& (__GNUC__ =�3 && 
+__GNUC_MINOR__
+ >= 5 || __GNUC__ > 3)
+
+112 #i�de�
+__off�tof
+
+
+113 

+	#__off�tof
+(
+ty�
+, 
+f�ld
+�
+	`__bu�t�_off�tof
+�y�, f�ld)
+
+	)
+
+115 

+	#off�tof
+(
+ty�
+, 
+f�ld
+�
+	`__bu�t�_off�tof
+�y�, f�ld)
+
+	)
+
+117 #i�de�
+__off�tof
+
+
+118 

+	#__off�tof
+(
+ty�
+, 
+f�ld
+�((
+size_t
+)(&(�y� *)0)->f�ld))
+
+	)
+
+120 

+	#off�tof
+(
+ty�
+, 
+f�ld
+�((
+size_t
+)(&(�y� *)0)->f�ld))
+
+	)
+
+126 #unde�
+__�ed_�rdiff_t
+
+
+127 #unde�
+__�ed_size_t
+
+
+128 #unde�
+__�ed_wch�_t
+
+
+129 #unde�
+__�ed_w�t_t
+
+
+130 #unde�
+__�ed_NULL
+
+
+	@/usr/include/stdio.h
+
+61 #i�def 
+_STDIO_H_
+
+
+62 

+	#_STDIO_H_
+
+
+	)
+
+64 
+	~<_ty�s.h
+>
+
+66 #i�de�
+_VA_LIST
+
+
+67 

+	#_VA_LIST
+
+
+	)
+
+70 
+__d�w�_va_li�
+ 
+	tva_li�
+;
+
+73 #i�def 
+_OFF_T
+
+
+74 

+	#_OFF_T
+
+
+	)
+
+75 
+__d�w�_off_t
+ 
+	toff_t
+;
+
+78 #i�def 
+_SIZE_T
+
+
+79 

+	#_SIZE_T
+
+
+	)
+
+80 
+__d�w�_size_t
+ 
+	tsize_t
+;
+
+83 #i�de�
+NULL
+
+
+84 

+	#NULL
+ 
+__DARWIN_NULL
+
+
+	)
+
+87 
+__d�w�_off_t
+ 
+	t�os_t
+;
+
+89 

+	#_FSTDIO
+
+
+	)
+
+98 
+	s__sbuf
+ {
+
+99 *
+	m_ba�
+;
+
+100 
+	m_size
+;
+
+104 
+	g__sFILEX
+;
+
+132 
+	s__sFILE
+ {
+
+133 *
+	m_p
+;
+
+134 
+	m_r
+;
+
+135 
+	m_w
+;
+
+136 
+	m_�ags
+;
+
+137 
+	m_f�e
+;
+
+138 
+__sbuf
+ 
+	m_bf
+;
+
+139 
+	m_lbfsize
+;
+
+142 *
+	m_cook�
+;
+
+143 (*
+	m_�o�
+)(*);
+
+144 (*
+	m_�ad
+) (*, *, );
+
+145 
+�os_t
+ (*
+_�ek
+�(*, 
+	m�os_t
+, );
+
+146 (*
+	m_wr�e
+)(*, const *, );
+
+149 
+__sbuf
+ 
+	m_ub
+;
+
+150 
+__sFILEX
+ *
+	m_ex�a
+;
+
+151 
+	m_ur
+;
+
+154 
+	m_ubuf
+[3];
+
+155 
+	m_nbuf
+[1];
+
+158 
+__sbuf
+ 
+	m_lb
+;
+
+161 
+	m_blksize
+;
+
+162 
+�os_t
+ 
+	m_off�t
+;
+
+163 } 
+	tFILE
+;
+
+165 
+	g__BEGIN_DECLS
+
+
+166 #i�
+__DARWIN_UNIX03
+
+
+167 

+FILE
+ *
+__�d�p
+;
+
+168 

+FILE
+ *
+__�dou�
+;
+
+169 

+FILE
+ *
+__�d��
+;
+
+171 

+FILE
+ 
+__sF
+[];
+
+173 
+	g__END_DECLS
+
+
+175 

+	#__SLBF
+ 0x0001
+
+	)
+
+176 

+	#__SNBF
+ 0x0002
+
+	)
+
+177 

+	#__SRD
+ 0x0004
+
+	)
+
+178 

+	#__SWR
+ 0x0008
+
+	)
+
+180 

+	#__SRW
+ 0x0010
+
+	)
+
+181 

+	#__SEOF
+ 0x0020
+
+	)
+
+182 

+	#__SERR
+ 0x0040
+
+	)
+
+183 

+	#__SMBF
+ 0x0080
+
+	)
+
+184 

+	#__SAPP
+ 0x0100
+
+	)
+
+185 

+	#__SSTR
+ 0x0200
+
+	)
+
+186 

+	#__SOPT
+ 0x0400
+
+	)
+
+187 

+	#__SNPT
+ 0x0800
+
+	)
+
+188 

+	#__SOFF
+ 0x1000
+
+	)
+
+189 

+	#__SMOD
+ 0x2000
+
+	)
+
+190 

+	#__SALC
+ 0x4000
+
+	)
+
+191 

+	#__SIGN
+ 0x8000
+
+	)
+
+202 

+	#_IOFBF
+ 0
+
+	)
+
+203 

+	#_IOLBF
+ 1
+
+	)
+
+204 

+	#_IONBF
+ 2
+
+	)
+
+206 

+	#BUFSIZ
+ 1024
+
+	)
+
+207 

+	#EOF
+ (-1)
+
+	)
+
+215 

+	#FOPEN_MAX
+ 20
+
+	)
+
+216 

+	#FILENAME_MAX
+ 1024
+
+	)
+
+219 #i�de�
+_ANSI_SOURCE
+
+
+220 

+	#P_tmpd�
+ "/v�/tmp/"
+
+	)
+
+222 

+	#L_tm�am
+ 1024
+
+	)
+
+223 

+	#TMP_MAX
+ 308915776
+
+	)
+
+225 #i�de�
+SEEK_SET
+
+
+226 

+	#SEEK_SET
+ 0
+
+	)
+
+228 #i�de�
+SEEK_CUR
+
+
+229 

+	#SEEK_CUR
+ 1
+
+	)
+
+231 #i�de�
+SEEK_END
+
+
+232 

+	#SEEK_END
+ 2
+
+	)
+
+235 #i�
+__DARWIN_UNIX03
+
+
+236 

+	#�d�
+ 
+__�d�p
+
+
+	)
+
+237 

+	#�dout
+ 
+__�dou�
+
+
+	)
+
+238 

+	#�d�r
+ 
+__�d��
+
+
+	)
+
+240 

+	#�d�
+ (&
+__sF
+[0])
+
+	)
+
+241 

+	#�dout
+ (&
+__sF
+[1])
+
+	)
+
+242 

+	#�d�r
+ (&
+__sF
+[2])
+
+	)
+
+248 
+__BEGIN_DECLS
+
+
+249 
+����
+(
+FILE
+ *);
+
+250 
+f�o�
+(
+FILE
+ *);
+
+251 
+�of
+(
+FILE
+ *);
+
+252 
+��
+(
+FILE
+ *);
+
+253 
+f�ush
+(
+FILE
+ *);
+
+254 
+fg�c
+(
+FILE
+ *);
+
+255 
+fg�pos
+(
+FILE
+ * 
+__��ri�
+, 
+�os_t
+ *);
+
+256 *
+fg�s
+(* 
+__��ri�
+, , 
+FILE
+ *);
+
+257 
+FILE
+ *
+fݒ
+(cڡ * 
+__��ri�
+, const * __restrict);
+
+258 
+	$�r�tf
+(
+FILE
+ * 
+__��ri�
+, cڡ * __��ri�, ...�
+	`__DARWIN_LDBL_COMPAT
+(
+�r�tf
+);
+
+259 
+	`�utc
+(, 
+FILE
+ *);
+
+260 
+	$�uts
+(cڡ * 
+__��ri�
+, 
+FILE
+ * __��ri��
+	`__DARWIN_ALIAS
+(
+�uts
+);
+
+261 
+size_t
+ 
+	`�d
+(* 
+__��ri�
+, size_t, size_t, 
+FILE
+ * __restrict);
+
+262 
+FILE
+ *
+	$�eݒ
+(cڡ * 
+__��ri�
+, const * __restrict,
+
+263 
+FILE
+ * 
+__��ri�
+�
+	`__DARWIN_ALIAS
+(
+�eݒ
+);
+
+264 
+	$fs�nf
+(
+FILE
+ * 
+__��ri�
+, cڡ * __��ri�, ...�
+	`__DARWIN_LDBL_COMPAT
+(
+fs�nf
+);
+
+265 
+	`f�ek
+(
+FILE
+ *, , );
+
+266 
+	`f��os
+(
+FILE
+ *, cڡ 
+�os_t
+ *);
+
+267 
+	`�l
+(
+FILE
+ *);
+
+268 
+size_t
+ 
+	$fwr�e
+(cڡ * 
+__��ri�
+, 
+size_t
+, size_t, 
+FILE
+ * __��ri��
+	`__DARWIN_ALIAS
+(
+fwr�e
+);
+
+269 
+	`g�c
+(
+FILE
+ *);
+
+270 
+	`g�ch�
+();
+
+271 *
+	`g�s
+(*);
+
+272 #i�!
+	`def�ed
+(
+_ANSI_SOURCE
+�&& (!def�ed(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+))
+
+273 

+__cڡ
+ 
+sys_ü
+;
+
+274 

+__cڡ
+ *__cڡ 
+sys_��i�
+[];
+
+276 
+	`���
+(const *);
+
+277 
+	$��tf
+(cڡ * 
+__��ri�
+, ...�
+	`__DARWIN_LDBL_COMPAT
+(
+��tf
+);
+
+278 
+	`putc
+(, 
+FILE
+ *);
+
+279 
+	`putch�
+();
+
+280 
+	`puts
+(const *);
+
+281 
+	`�move
+(const *);
+
+282 
+	`��me
+ (const *, const *);
+
+283 
+	`�w�d
+(
+FILE
+ *);
+
+284 
+	$s�nf
+(cڡ * 
+__��ri�
+, ...�
+	`__DARWIN_LDBL_COMPAT
+(
+s�nf
+);
+
+285 
+	`�tbuf
+(
+FILE
+ * 
+__��ri�
+, * __restrict);
+
+286 
+	`�tvbuf
+(
+FILE
+ * 
+__��ri�
+, * __��ri�, , 
+size_t
+);
+
+287 
+	$�r�tf
+(* 
+__��ri�
+, cڡ * __��ri�, ...�
+	`__DARWIN_LDBL_COMPAT
+(
+�r�tf
+);
+
+288 
+	$ss�nf
+(cڡ * 
+__��ri�
+, cڡ * __��ri�, ...�
+	`__DARWIN_LDBL_COMPAT
+(
+ss�nf
+);
+
+289 
+FILE
+ *
+	`tmpf�e
+();
+
+290 *
+	`tm�am
+(*);
+
+291 
+	`ung�c
+(, 
+FILE
+ *);
+
+292 
+	$v�r�tf
+(
+FILE
+ * 
+__��ri�
+, cڡ * __��ri�, 
+va_li�
+�
+	`__DARWIN_LDBL_COMPAT
+(
+v�r�tf
+);
+
+293 
+	$v��tf
+(cڡ * 
+__��ri�
+, 
+va_li�
+�
+	`__DARWIN_LDBL_COMPAT
+(
+v��tf
+);
+
+294 
+	$v�r�tf
+(* 
+__��ri�
+, cڡ * __��ri�, 
+va_li�
+�
+	`__DARWIN_LDBL_COMPAT
+(
+v�r�tf
+);
+
+295 #i�!
+	`def�ed
+(
+_ANSI_SOURCE
+�&& (!def�ed(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+))
+
+296 
+	$a�r�tf
+(**, cڡ *, ...�
+	`__DARWIN_LDBL_COMPAT
+(
+a�r�tf
+);
+
+297 
+	$va�r�tf
+(**, cڡ *, 
+va_li�
+�
+	`__DARWIN_LDBL_COMPAT
+(
+va�r�tf
+);
+
+299 
+__END_DECLS
+
+
+304 #i�de�
+_ANSI_SOURCE
+
+
+305 

+	#L_��mid
+ 1024
+
+	)
+
+307 
+__BEGIN_DECLS
+
+
+308 *
+	`��mid
+(*);
+
+309 #i�!
+	`def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+310 *
+	`��mid_r
+(*);
+
+312 
+FILE
+ *
+	`fdݒ
+(, const *);
+
+313 #i�!
+	`def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+314 *
+	`fg��
+(
+FILE
+ *, 
+size_t
+ *);
+
+316 
+	`f��o
+(
+FILE
+ *);
+
+317 
+	`�ockf�e
+(
+FILE
+ *);
+
+318 #i�!
+	`def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+319 
+__cڡ
+ 
+
+320 *
+	`fmtcheck
+(const *, const *);
+
+321 
+	`�urge
+(
+FILE
+ *);
+
+323 
+	`f�eko
+(
+FILE
+ *, 
+off_t
+, );
+
+324 
+off_t
+ 
+	`�lo
+(
+FILE
+ *);
+
+325 
+	`�rylockf�e
+(
+FILE
+ *);
+
+326 
+	`fu�ockf�e
+(
+FILE
+ *);
+
+327 
+	`g�c_u�ocked
+(
+FILE
+ *);
+
+328 
+	`g�ch�_u�ocked
+();
+
+329 #i�!
+	`def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+330 
+	`g�w
+(
+FILE
+ *);
+
+332 
+	`p�o�
+(
+FILE
+ *);
+
+333 
+FILE
+ *
+	`pݒ
+(const *, const *);
+
+334 
+	`putc_u�ocked
+(, 
+FILE
+ *);
+
+335 
+	`putch�_u�ocked
+();
+
+336 #i�!
+	`def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+337 
+	`putw
+(, 
+FILE
+ *);
+
+338 
+	`�tbuf�r
+(
+FILE
+ *, *, );
+
+339 
+	`���ebuf
+(
+FILE
+ *);
+
+341 
+	$���tf
+(* 
+__��ri�
+, 
+size_t
+, cڡ * __��ri�, ...�
+	`__DARWIN_LDBL_COMPAT
+(
+���tf
+);
+
+342 *
+	$�m�am
+(cڡ *, cڡ *�
+	`__DARWIN_ALIAS
+(
+�m�am
+);
+
+343 
+	$vfs�nf
+(
+FILE
+ * 
+__��ri�
+, cڡ * __��ri�, 
+va_li�
+�
+	`__DARWIN_LDBL_COMPAT
+(
+vfs�nf
+);
+
+344 
+	$vs�nf
+(cڡ * 
+__��ri�
+, 
+va_li�
+�
+	`__DARWIN_LDBL_COMPAT
+(
+vs�nf
+);
+
+345 
+	$v���tf
+(* 
+__��ri�
+, 
+size_t
+, cڡ * __��ri�, 
+va_li�
+�
+	`__DARWIN_LDBL_COMPAT
+(
+v���tf
+);
+
+346 
+	$vss�nf
+(cڡ * 
+__��ri�
+, cڡ * __��ri�, 
+va_li�
+�
+	`__DARWIN_LDBL_COMPAT
+(
+vss�nf
+);
+
+347 #i�!
+	`def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+348 
+FILE
+ *
+	`zݒ
+(const *, const *, );
+
+350 
+__END_DECLS
+
+
+355 #i�!
+	`def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+356 
+__BEGIN_DECLS
+
+
+357 
+FILE
+ *
+	`funݒ
+(const *,
+
+360 
+	$�os_t
+ (*)(*, 
+�os_t
+, ),
+
+362 
+__END_DECLS
+
+
+363 

+	#�ݒ
+(
+cook�
+, 
+�
+�
+	`funݒ
+(cook�, fn, 0, 0, 0)
+
+	)
+
+364 

+	#fwݒ
+(
+cook�
+, 
+�
+�
+	`funݒ
+(cook�, 0, fn, 0, 0)
+
+	)
+
+371 
+__BEGIN_DECLS
+
+
+372 
+	`__�g�
+(
+FILE
+ *);
+
+373 
+	$__svfs�nf
+(
+FILE
+ *, cڡ *, 
+va_li�
+�
+	`__DARWIN_LDBL_COMPAT
+(
+__svfs�nf
+);
+
+374 
+	`__swbuf
+(, 
+FILE
+ *);
+
+375 
+__END_DECLS
+
+
+381 

+	#__sg�c
+(
+p
+�(--�)->
+_r
+ < 0 ? 
+	`__�g�
+��: ()(*�)->
+_p
+++))
+
+	)
+
+382 #i�
+	`def�ed
+(
+__GNUC__
+�&& def�ed(
+__STDC__
+)
+
+383 
+__�l�e
+ 
+	$__�utc
+(
+_c
+, 
+FILE
+ *
+_p
+) {
+
+384 i�(--
+_p
+->
+_w
+ >�0 || (_p->_w >�_p->
+_lbfsize
+ && ()
+_c
+ != '\n'))
+
+385  (*
+_p
+->_p++ = 
+_c
+);
+
+387  (
+	`__swbuf
+(
+_c
+, 
+_p
+));
+
+388 
+	}
+}
+
+393 

+	#__�utc
+(
+c
+, 
+p
+) \
+
+394 (--(
+p
+)->
+_w
+ < 0 ? \
+
+395 (
+p
+)->
+_w
+ >��)->
+_lbfsize
+ ? \
+
+396 (*(
+p
+)->
+_p
+ = (
+c
+)), *(p)->_p != '\n' ? \
+
+397 ()*(
+p
+)->
+_p
+++ : \
+
+398 
+	`__swbuf
+('\n', 
+p
+) : \
+
+399 
+	`__swbuf
+(()(
+c
+), 
+p
+) : \
+
+400 (*(
+p
+)->
+_p
+ = (
+c
+), ()*�)->_p++))
+
+	)
+
+403 

+	#__s�of
+(
+p
+�((�)->
+_�ags
+ & 
+__SEOF
+�!�0)
+
+	)
+
+404 

+	#__s��
+(
+p
+�((�)->
+_�ags
+ & 
+__SERR
+�!�0)
+
+	)
+
+405 

+	#__s����
+(
+p
+�(()(�)->
+_�ags
+ &�~(
+__SERR
+|
+__SEOF
+)))
+
+	)
+
+406 

+	#__sf��o
+(
+p
+�(�)->
+_f�e
+)
+
+	)
+
+408 #i�de�
+_ANSI_SOURCE
+
+
+409 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+410 

+	#�of_u�ocked
+(
+p
+�
+	`__s�of
+�)
+
+	)
+
+411 

+	#��_u�ocked
+(
+p
+�
+	`__s��
+�)
+
+	)
+
+412 

+	#����_u�ocked
+(
+p
+�
+	`__s����
+�)
+
+	)
+
+413 

+	#f��o_u�ocked
+(
+p
+�
+	`__sf��o
+�)
+
+	)
+
+416 #i�de�
+l�t
+
+
+417 

+	#g�c_u�ocked
+(
+�
+�
+	`__sg�c
+(�)
+
+	)
+
+418 

+	#putc_u�ocked
+(
+x
+, 
+�
+�
+	`__�utc
+(x, fp)
+
+	)
+
+421 

+	#g�ch�_u�ocked
+(�
+	`g�c_u�ocked
+(
+�d�
+)
+
+	)
+
+422 

+	#putch�_u�ocked
+(
+x
+�
+	`putc_u�ocked
+(x, 
+�dout
+)
+
+	)
+
+425 #ifde�
+_USE_EXTENDED_LOCALES_
+
+
+426 
+	~<xlo��/_�dio.h
+>
+
+429 #i�
+def�ed
+ (
+__GNUC__
+�&& 
+_FORTIFY_SOURCE
+ > 0 && !def�ed (
+__�lu�lus
+)
+
+431 
+	~<�cu�/_�dio.h
+>
+
+	@/usr/include/stdlib.h
+
+58 #i�de�
+_STDLIB_H_
+
+
+59 

+	#_STDLIB_H_
+
+
+	)
+
+61 
+	~<ava�ab�.h
+>
+
+63 
+	~<_ty�s.h
+>
+
+64 #i�!
+def�ed
+(
+_ANSI_SOURCE
+)
+
+65 
+	~<sys/wa�.h
+>
+
+66 #i�(!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+))
+
+67 
+	~<�lo�.h
+>
+
+71 #i�def 
+_SIZE_T
+
+
+72 

+	#_SIZE_T
+
+
+	)
+
+75 
+__d�w�_size_t
+ 
+	tsize_t
+;
+
+78 #i�!
+def�ed
+(
+_ANSI_SOURCE
+�&& (!def�ed(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+))
+
+79 #i�de�
+_CT_RUNE_T
+
+
+80 

+	#_CT_RUNE_T
+
+
+	)
+
+81 
+__d�w�_�_ru�_t
+ 
+	t�_ru�_t
+;
+
+84 #i�de�
+_RUNE_T
+
+
+85 

+	#_RUNE_T
+
+
+	)
+
+86 
+__d�w�_ru�_t
+ 
+	tru�_t
+;
+
+90 #i�def 
+__�lu�lus
+
+
+91 #i�def 
+_WCHAR_T
+
+
+92 

+	#_WCHAR_T
+
+
+	)
+
+93 
+__d�w�_wch�_t
+ 
+	twch�_t
+;
+
+98 
+	mqu�
+;
+
+99 
+	m�m
+;
+
+100 } 
+	tdiv_t
+;
+
+103 
+	mqu�
+;
+
+104 
+	m�m
+;
+
+105 } 
+	tldiv_t
+;
+
+107 #i�!
+__DARWIN_NO_LONG_LONG
+
+
+109 
+	mqu�
+;
+
+110 
+	m�m
+;
+
+111 } 
+	t�div_t
+;
+
+114 #i�de�
+NULL
+
+
+115 

+	#NULL
+ 
+__DARWIN_NULL
+
+
+	)
+
+118 

+	#EXIT_FAILURE
+ 1
+
+	)
+
+119 

+	#EXIT_SUCCESS
+ 0
+
+	)
+
+121 

+	#RAND_MAX
+ 0x7fffffff
+
+	)
+
+123 #ifde�
+_USE_EXTENDED_LOCALES_
+
+
+124 
+	~<_xlo��.h
+>
+
+127 #i�de�
+MB_CUR_MAX
+
+
+128 #ifde�
+_USE_EXTENDED_LOCALES_
+
+
+129 

+	#MB_CUR_MAX
+ (
+	`___mb_cur_max
+())
+
+	)
+
+130 #i�de�
+MB_CUR_MAX_L
+
+
+131 

+	#MB_CUR_MAX_L
+(
+x
+�(
+	`___mb_cur_max_l
+(x))
+
+	)
+
+134 

+__mb_cur_max
+;
+
+135 

+	#MB_CUR_MAX
+ 
+__mb_cur_max
+
+
+	)
+
+139 #i�!
+def�ed
+(
+_ANSI_SOURCE
+�&& (!def�ed(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)) \
+
+140 && 
+def�ed
+(
+_USE_EXTENDED_LOCALES_
+�&& !
+	$def�ed
+(
+MB_CUR_MAX_L
+)
+
+141 

+	#MB_CUR_MAX_L
+(
+x
+�(
+	`___mb_cur_max_l
+(x))
+
+	)
+
+144 
+__BEGIN_DECLS
+
+
+145 
+	$ab�t
+(�
+__d�d2
+;
+
+146 
+	$abs
+(�
+__pu�2
+;
+
+147 
+	`�ex�
+((*)());
+
+148 
+	`�of
+(const *);
+
+149 
+	`�oi
+(const *);
+
+150 
+	`��
+(const *);
+
+151 #i�!
+__DARWIN_NO_LONG_LONG
+
+
+153 
+	`��l
+(const *);
+
+155 *
+	`b��ch
+(cڡ *, cڡ *, 
+size_t
+,
+
+156 
+size_t
+, (*)(const *, const *));
+
+157 *
+	`��oc
+(
+size_t
+, size_t);
+
+158 
+div_t
+ 
+	$div
+(, �
+__pu�2
+;
+
+159 
+	$ex�
+(�
+__d�d2
+;
+
+160 
+	`�
+(*);
+
+161 *
+	`g��v
+(const *);
+
+162 
+	$�bs
+(�
+__pu�2
+;
+
+163 
+ldiv_t
+ 
+	$ldiv
+(, �
+__pu�2
+;
+
+164 #i�!
+__DARWIN_NO_LONG_LONG
+
+
+166 
+	`�abs
+();
+
+167 
+�div_t
+ 
+	`�div
+(, );
+
+169 *
+	`m�loc
+(
+size_t
+);
+
+170 
+	`mb�n
+(cڡ *, 
+size_t
+);
+
+171 
+size_t
+ 
+	`mb�owcs
+(
+wch�_t
+ * 
+__��ri�
+ , const * __restrict, size_t);
+
+172 
+	`mbtowc
+(
+wch�_t
+ * 
+__��ri�
+, cڡ * __��ri�, 
+size_t
+);
+
+173 
+	`qs�t
+(*, 
+size_t
+, size_t,
+
+175 
+	`�nd
+();
+
+176 *
+	`��loc
+(*, 
+size_t
+);
+
+177 
+	`��d
+();
+
+178 
+	$��od
+(cڡ *, **�
+	`__DARWIN_ALIAS
+(
+��od
+);
+
+179 
+	$��of
+(cڡ *, **�
+	`__DARWIN_ALIAS
+(
+��of
+);
+
+180 
+	`���
+(const *, **, );
+
+182 
+	$���d
+(cڡ *, **�
+	`__DARWIN_LDBL_COMPAT
+(
+���d
+);
+
+183 #i�!
+__DARWIN_NO_LONG_LONG
+
+
+185 
+	`���l
+(const *, **, );
+
+188 
+	`��oul
+(const *, **, );
+
+189 #i�!
+__DARWIN_NO_LONG_LONG
+
+
+191 
+	`��ou�
+(const *, **, );
+
+193 
+	$sy�em
+(cڡ *�
+	`__DARWIN_ALIAS_C
+(
+sy�em
+);
+
+194 
+size_t
+ 
+	`wc�ombs
+(* 
+__��ri�
+, cڡ 
+wch�_t
+ * __restrict, size_t);
+
+195 
+	`w�omb
+(*, 
+wch�_t
+);
+
+197 #i�de�
+_ANSI_SOURCE
+
+
+198 
+	$_Ex�
+(�
+__d�d2
+;
+
+199 
+	`a64l
+(const *);
+
+200 
+	`d�nd48
+();
+
+201 *
+	`ecvt
+(, , *
+__��ri�
+, *__restrict);
+
+202 
+	`��d48
+([3]);
+
+203 *
+	`fcvt
+(, , *
+__��ri�
+, *__restrict);
+
+204 *
+	`gcvt
+(, , *);
+
+205 
+	`g�sub�t
+(**, * const *, **);
+
+206 
+	`g���
+();
+
+207 #i�
+__DARWIN_UNIX03
+
+
+208 *
+	`����e
+(, *, 
+size_t
+);
+
+210 *
+	`����e
+(, *, );
+
+212 
+	`j�nd48
+([3]);
+
+213 *
+	`l64a
+();
+
+214 
+	`lc�g48
+([7]);
+
+215 
+	`̪d48
+();
+
+216 *
+	`mk�mp
+(*);
+
+217 
+	`mk�emp
+(*);
+
+218 
+	`m�nd48
+();
+
+219 
+	`Īd48
+([3]);
+
+220 
+	`posix_ݒ�
+();
+
+221 *
+	`��ame
+();
+
+222 
+	$pu�nv
+(*�
+	`__DARWIN_ALIAS
+(
+pu�nv
+);
+
+223 
+	`�ndom
+();
+
+224 
+	`�nd_r
+(*);
+
+225 #i�(
+__DARWIN_UNIX03
+ && !
+	`def�ed
+(
+_POSIX_C_SOURCE
+)�|| def�ed(
+_DARWIN_C_SOURCE
+�|| def�ed(
+_DARWIN_BETTER_REALPATH
+)
+
+226 *
+	$���th
+(cڡ * 
+__��ri�
+, * __��ri��
+	`__DARWIN_EXTSN
+(
+���th
+);
+
+228 *
+	$���th
+(cڡ * 
+__��ri�
+, * __��ri��
+	`__DARWIN_ALIAS
+(
+���th
+);
+
+231 *
+	`�ed48
+([3]);
+
+232 
+	$��nv
+(cڡ *, cڡ *, �
+	`__DARWIN_ALIAS
+(
+��nv
+);
+
+233 #i�
+__DARWIN_UNIX03
+
+
+234 
+	$�tkey
+(cڡ *�
+	`__DARWIN_ALIAS
+(
+�tkey
+);
+
+236 
+	`�tkey
+(const *);
+
+238 *
+	`�t��e
+(const *);
+
+239 
+	`��d48
+();
+
+240 #i�
+__DARWIN_UNIX03
+
+
+241 
+	`��dom
+();
+
+243 
+	`��dom
+();
+
+245 
+	`u�ock�
+();
+
+246 #i�
+__DARWIN_UNIX03
+
+
+247 
+	$un��nv
+(cڡ *�
+	`__DARWIN_ALIAS
+(
+un��nv
+);
+
+249 
+	`un��nv
+(const *);
+
+253 #i�!
+	`def�ed
+(
+_ANSI_SOURCE
+�&& (!def�ed(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+))
+
+254 
+	~<mach�e/ty�s.h
+>
+
+256 #i�de�
+_DEV_T
+
+
+257 
+__d�w�_dev_t
+ 
+	tdev_t
+;
+
+258 

+	#_DEV_T
+
+
+	)
+
+261 #i�def 
+_MODE_T
+
+
+262 
+__d�w�_mode_t
+ 
+	tmode_t
+;
+
+263 

+	#_MODE_T
+
+
+	)
+
+266 
+u_�t32_t
+
+
+267 
+	`�c4�ndom
+();
+
+268 
+	`�c4�ndom_add�ndom
+(*
+d�
+, 
+d��n
+);
+
+269 
+	`�c4�ndom_��
+();
+
+272 *
+	`cg��p
+(*, const *, );
+
+273 
+	`cg��o�
+();
+
+274 
+	`cg��t
+(**, **, const *);
+
+275 
+	`cg�f��
+(**, **);
+
+276 
+	`cg�m�ch
+(const *, const *);
+
+277 
+	`cg��xt
+(**, **);
+
+278 
+	`cg�num
+(*, const *, *);
+
+279 
+	`cg��t
+(const *);
+
+280 
+	`cg��r
+(*, const *, **);
+
+281 
+	`cg�u�r
+(*, const *, **);
+
+283 
+	$d�m�
+(, �
+	$__DARWIN_1050
+(
+d�m�
+�
+__AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_5
+;
+
+284 *
+	`dev�me
+(
+dev_t
+, 
+mode_t
+);
+
+285 *
+	`dev�me_r
+(
+dev_t
+, 
+mode_t
+, *
+buf
+, 
+�n
+);
+
+286 *
+	`g�bsize
+(*, *);
+
+287 
+	`g�l�davg
+([], );
+
+289 *
+	`g��og�me
+();
+
+291 
+	`h�ps�t
+(*, 
+size_t
+, size_t,
+
+293 
+	`m�ges�t
+(*, 
+size_t
+, size_t,
+
+295 
+	`qs�t_r
+(*, 
+size_t
+, size_t, *,
+
+297 
+	`�dixs�t
+(const **, , const *,
+
+299 
+	`��rog�me
+(const *);
+
+300 
+	`�adixs�t
+(const **, , const *,
+
+302 
+	`��ddev
+();
+
+303 
+	`��domdev
+();
+
+304 *
+	`��locf
+(*, 
+size_t
+);
+
+305 #i�!
+__DARWIN_NO_LONG_LONG
+
+
+307 
+	`��oq
+(const *, **, );
+
+309 
+	`��ouq
+(const *, **, );
+
+311 
*
+subݏrg
+;
+
+312 *
+	`v�loc
+(
+size_t
+);
+
+316 #i�!
+	`def�ed
+(
+__�lu�lus
+�&& def�ed(
+__WCHAR_MAX__
+) && __WCHAR_MAX__ <= 0xffffU
+
+317 #�agm�
+GCC
+ 
+pois�
+ 
+mb�owcs
+ 
+mbtowc
+ 
+wc�ombs
+ 
+w�omb
+
+
+319 
+__END_DECLS
+
+
+321 #ifde�
+_USE_EXTENDED_LOCALES_
+
+
+322 
+	~<xlo��/_�dlib.h
+>
+
+	@/usr/include/sys/mman.h
+
+76 #i�def 
+_SYS_MMAN_H_
+
+
+77 

+	#_SYS_MMAN_H_
+
+
+	)
+
+79 
+	~<sys/���pi�ts.h
+>
+
+80 
+	~<sys/cdefs.h
+>
+
+82 
+	~<sys/_ty�s.h
+>
+
+88 #i�def 
+_MODE_T
+
+
+89 
+__d�w�_mode_t
+ 
+	tmode_t
+;
+
+90 

+	#_MODE_T
+
+
+	)
+
+93 #i�de�
+_OFF_T
+
+
+94 
+__d�w�_off_t
+ 
+	toff_t
+;
+
+95 

+	#_OFF_T
+
+
+	)
+
+98 #i�de�
+_SIZE_T
+
+
+99 

+	#_SIZE_T
+
+
+	)
+
+100 
+__d�w�_size_t
+ 
+	tsize_t
+;
+
+107 

+	#PROT_NONE
+ 0x00
+
+	)
+
+108 

+	#PROT_READ
+ 0x01
+
+	)
+
+109 

+	#PROT_WRITE
+ 0x02
+
+	)
+
+110 

+	#PROT_EXEC
+ 0x04
+
+	)
+
+116 

+	#MAP_SHARED
+ 0x0001
+
+	)
+
+117 

+	#MAP_PRIVATE
+ 0x0002
+
+	)
+
+118 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+119 

+	#MAP_COPY
+ 
+MAP_PRIVATE
+
+
+	)
+
+125 

+	#MAP_FIXED
+ 0x0010
+
+	)
+
+126 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+127 

+	#MAP_RENAME
+ 0x0020
+
+	)
+
+128 

+	#MAP_NORESERVE
+ 0x0040
+
+	)
+
+129 

+	#MAP_RESERVED0080
+ 0x0080
+
+	)
+
+130 

+	#MAP_NOEXTEND
+ 0x0100
+
+	)
+
+131 

+	#MAP_HASSEMAPHORE
+ 0x0200
+
+	)
+
+132 

+	#MAP_NOCACHE
+ 0x0400
+
+	)
+
+138 

+	#MCL_CURRENT
+ 0x0001
+
+	)
+
+139 

+	#MCL_FUTURE
+ 0x0002
+
+	)
+
+144 

+	#MAP_FAILED
+ ((*)-1�
+
+	)
+
+149 

+	#MS_ASYNC
+ 0x0001
+
+	)
+
+150 

+	#MS_INVALIDATE
+ 0x0002
+
+	)
+
+151 

+	#MS_SYNC
+ 0x0010
+
+	)
+
+153 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+154 

+	#MS_KILLPAGES
+ 0x0004
+
+	)
+
+155 

+	#MS_DEACTIVATE
+ 0x0008
+
+	)
+
+160 

+	#MAP_FILE
+ 0x0000
+
+	)
+
+161 

+	#MAP_ANON
+ 0x1000
+
+	)
+
+168 

+	#POSIX_MADV_NORMAL
+ 0
+
+	)
+
+169 

+	#POSIX_MADV_RANDOM
+ 1
+
+	)
+
+170 

+	#POSIX_MADV_SEQUENTIAL
+ 2
+
+	)
+
+171 

+	#POSIX_MADV_WILLNEED
+ 3
+
+	)
+
+172 

+	#POSIX_MADV_DONTNEED
+ 4
+
+	)
+
+174 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+175 

+	#MADV_NORMAL
+ 
+POSIX_MADV_NORMAL
+
+
+	)
+
+176 

+	#MADV_RANDOM
+ 
+POSIX_MADV_RANDOM
+
+
+	)
+
+177 

+	#MADV_SEQUENTIAL
+ 
+POSIX_MADV_SEQUENTIAL
+
+
+	)
+
+178 

+	#MADV_WILLNEED
+ 
+POSIX_MADV_WILLNEED
+
+
+	)
+
+179 

+	#MADV_DONTNEED
+ 
+POSIX_MADV_DONTNEED
+
+
+	)
+
+180 

+	#MADV_FREE
+ 5
+
+	)
+
+185 

+	#MINCORE_INCORE
+ 0x1
+
+	)
+
+186 

+	#MINCORE_REFERENCED
+ 0x2
+
+	)
+
+187 

+	#MINCORE_MODIFIED
+ 0x4
+
+	)
+
+188 

+	#MINCORE_REFERENCED_OTHER
+ 0x8
+
+	)
+
+189 

+	#MINCORE_MODIFIED_OTHER
+ 0x10
+
+	)
+
+194 
+__BEGIN_DECLS
+
+
+196 
+mlock�l
+();
+
+197 
+mu�ock�l
+();
+
+199 
+mlock
+(cڡ *, 
+size_t
+);
+
+200 #i�de�
+_MMAP
+
+
+201 

+	#_MMAP
+
+
+	)
+
+203 * 
+	$mm�
+(*, 
+size_t
+, , , , 
+off_t
+�
+	`__DARWIN_ALIAS
+(
+mm�
+);
+
+206 
+	$m��e�
+(*, 
+size_t
+, �
+	`__DARWIN_ALIAS
+(
+m��e�
+);
+
+208 
+	$msync
+(*, 
+size_t
+, �
+	`__DARWIN_ALIAS_C
+(
+msync
+);
+
+210 
+	`mu�ock
+(cڡ *, 
+size_t
+);
+
+212 
+	$munm�
+(*, 
+size_t
+�
+	`__DARWIN_ALIAS
+(
+munm�
+);
+
+214 
+	`shm_ݒ
+(const *, , ...);
+
+215 
+	`shm_uƚk
+(const *);
+
+217 
+	`posix_madvi�
+(*, 
+size_t
+, );
+
+219 #i�!
+	`def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+220 
+	`madvi�
+(*, 
+size_t
+, );
+
+221 
+	`m�c�e
+(cڡ *, 
+size_t
+, *);
+
+222 
+	`m�h��
+(*, 
+size_t
+, );
+
+224 
+__END_DECLS
+
+
+	@/usr/include/sys/stat.h
+
+70 #i�de�
+_SYS_STAT_H_
+
+
+71 

+	#_SYS_STAT_H_
+
+
+	)
+
+73 
+	~<sys/_ty�s.h
+>
+
+74 
+	~<sys/cdefs.h
+>
+
+77 

+	#__�ed_�ru�_time�ec
+
+
+	)
+
+78 
+	~<sys/_�ru�s.h
+>
+
+85 #i�de�
+_BLKCNT_T
+
+
+86 
+__d�w�_blk�t_t
+ 
+	tblk�t_t
+;
+
+87 

+	#_BLKCNT_T
+
+
+	)
+
+90 #i�de�
+_BLKSIZE_T
+
+
+91 
+__d�w�_blksize_t
+ 
+	tblksize_t
+;
+
+92 

+	#_BLKSIZE_T
+
+
+	)
+
+95 #i�de�
+_DEV_T
+
+
+96 
+__d�w�_dev_t
+ 
+	tdev_t
+;
+
+97 

+	#_DEV_T
+
+
+	)
+
+100 #i�def 
+_INO_T
+
+
+101 
+__d�w�_�o_t
+ 
+	t�o_t
+;
+
+102 

+	#_INO_T
+
+
+	)
+
+105 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+106 #i�def 
+_INO64_T
+
+
+107 
+__d�w�_�o64_t
+ 
+	t�o64_t
+;
+
+108 

+	#_INO64_T
+
+
+	)
+
+112 #i�def 
+_MODE_T
+
+
+113 
+__d�w�_mode_t
+ 
+	tmode_t
+;
+
+114 

+	#_MODE_T
+
+
+	)
+
+117 #i�de�
+_NLINK_T
+
+
+118 
+__u�t16_t
+ 
+	tƚk_t
+;
+
+119 

+	#_NLINK_T
+
+
+	)
+
+122 #i�de�
+_UID_T
+
+
+123 
+__d�w�_uid_t
+ 
+	tuid_t
+;
+
+124 

+	#_UID_T
+
+
+	)
+
+127 #i�de�
+_GID_T
+
+
+128 
+__d�w�_gid_t
+ 
+	tgid_t
+;
+
+129 

+	#_GID_T
+
+
+	)
+
+132 #i�de�
+_OFF_T
+
+
+133 
+__d�w�_off_t
+ 
+	toff_t
+;
+
+134 

+	#_OFF_T
+
+
+	)
+
+137 #i�def 
+_TIME_T
+
+
+138 

+	#_TIME_T
+
+
+	)
+
+139 
+__d�w�_time_t
+ 
+	ttime_t
+;
+
+143 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+152 
+	so��
+ {
+
+153 
+__u�t16_t
+ 
+	m�_dev
+;
+
+154 
+�o_t
+ 
+	m�_�o
+;
+
+155 
+mode_t
+ 
+	m�_mode
+;
+
+156 
+ƚk_t
+ 
+	m�_ƚk
+;
+
+157 
+__u�t16_t
+ 
+	m�_uid
+;
+
+158 
+__u�t16_t
+ 
+	m�_gid
+;
+
+159 
+__u�t16_t
+ 
+	m�_rdev
+;
+
+160 
+__�t32_t
+ 
+	m�_size
+;
+
+161 
+time�ec
+ 
+	m�_�ime�ec
+;
+
+162 
+time�ec
+ 
+	m�_mtime�ec
+;
+
+163 
+time�ec
+ 
+	m�_�ime�ec
+;
+
+164 
+__�t32_t
+ 
+	m�_blksize
+;
+
+165 
+__�t32_t
+ 
+	m�_blocks
+;
+
+166 
+__u�t32_t
+ 
+	m�_�ags
+;
+
+167 
+__u�t32_t
+ 
+	m�_g�
+;
+
+170 

+	#__DARWIN_STRUCT_STAT64_TIMES
+ \
+
+171 
+time�ec
+ 
+�_�ime�ec
+; \
+
+172 
+time�ec
+ 
+�_mtime�ec
+; \
+
+173 
+time�ec
+ 
+�_�ime�ec
+; \
+
+174 
+time�ec
+ 
+�_b�thtime�ec
+;
+
+	)
+
+178 

+	#__DARWIN_STRUCT_STAT64_TIMES
+ \
+
+179 
+time_t
+ 
+�_�ime
+; \
+
+180 
+�_�im��c
+; \
+
+181 
+time_t
+ 
+�_mtime
+; \
+
+182 
+�_mtim��c
+; \
+
+183 
+time_t
+ 
+�_�ime
+; \
+
+184 
+�_�im��c
+; \
+
+185 
+time_t
+ 
+�_b�thtime
+; \
+
+186 
+�_b�thtim��c
+;
+
+	)
+
+200 

+	#__DARWIN_STRUCT_STAT64
+ { \
+
+201 
+dev_t
+ 
+�_dev
+; \
+
+202 
+mode_t
+ 
+�_mode
+; \
+
+203 
+ƚk_t
+ 
+�_ƚk
+; \
+
+204 
+__d�w�_�o64_t
+ 
+�_�o
+; \
+
+205 
+uid_t
+ 
+�_uid
+; \
+
+206 
+gid_t
+ 
+�_gid
+; \
+
+207 
+dev_t
+ 
+�_rdev
+; \
+
+208 
+__DARWIN_STRUCT_STAT64_TIMES
+ \
+
+209 
+off_t
+ 
+�_size
+; \
+
+210 
+blk�t_t
+ 
+�_blocks
+; \
+
+211 
+blksize_t
+ 
+�_blksize
+; \
+
+212 
+__u�t32_t
+ 
+�_�ags
+; \
+
+213 
+__u�t32_t
+ 
+�_g�
+; \
+
+214 
+__�t32_t
+ 
+�_l��e
+; \
+
+215 
+__�t64_t
+ 
+�_q��e
+[2]; \
+
+216 }
+
+	)
+
+222 #i�
+__DARWIN_64_BIT_INO_T
+
+
+224 
+��
+ 
+	g__DARWIN_STRUCT_STAT64
+;
+
+228 
+	s��
+ {
+
+229 
+dev_t
+ 
+	m�_dev
+;
+
+230 
+�o_t
+ 
+	m�_�o
+;
+
+231 
+mode_t
+ 
+	m�_mode
+;
+
+232 
+ƚk_t
+ 
+	m�_ƚk
+;
+
+233 
+uid_t
+ 
+	m�_uid
+;
+
+234 
+gid_t
+ 
+	m�_gid
+;
+
+235 
+dev_t
+ 
+	m�_rdev
+;
+
+236 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+237 
+time�ec
+ 
+	m�_�ime�ec
+;
+
+238 
+time�ec
+ 
+	m�_mtime�ec
+;
+
+239 
+time�ec
+ 
+	m�_�ime�ec
+;
+
+241 
+time_t
+ 
+	m�_�ime
+;
+
+242 
+	m�_�im��c
+;
+
+243 
+time_t
+ 
+	m�_mtime
+;
+
+244 
+	m�_mtim��c
+;
+
+245 
+time_t
+ 
+	m�_�ime
+;
+
+246 
+	m�_�im��c
+;
+
+248 
+off_t
+ 
+	m�_size
+;
+
+249 
+blk�t_t
+ 
+	m�_blocks
+;
+
+250 
+blksize_t
+ 
+	m�_blksize
+;
+
+251 
+__u�t32_t
+ 
+	m�_�ags
+;
+
+252 
+__u�t32_t
+ 
+	m�_g�
+;
+
+253 
+__�t32_t
+ 
+	m�_l��e
+;
+
+254 
+__�t64_t
+ 
+	m�_q��e
+[2];
+
+259 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+261 
+��64
+ 
+	g__DARWIN_STRUCT_STAT64
+;
+
+268 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+269 

+	#�_�ime
+ 
+�_�ime�ec
+.
+tv_�c
+
+
+	)
+
+270 

+	#�_mtime
+ 
+�_mtime�ec
+.
+tv_�c
+
+
+	)
+
+271 

+	#�_�ime
+ 
+�_�ime�ec
+.
+tv_�c
+
+
+	)
+
+272 

+	#�_b�thtime
+ 
+�_b�thtime�ec
+.
+tv_�c
+
+
+	)
+
+279 #i�de�
+S_IFMT
+
+
+281 

+	#S_IFMT
+ 0170000
+
+	)
+
+282 

+	#S_IFIFO
+ 0010000
+
+	)
+
+283 

+	#S_IFCHR
+ 0020000
+
+	)
+
+284 

+	#S_IFDIR
+ 0040000
+
+	)
+
+285 

+	#S_IFBLK
+ 0060000
+
+	)
+
+286 

+	#S_IFREG
+ 0100000
+
+	)
+
+287 

+	#S_IFLNK
+ 0120000
+
+	)
+
+288 

+	#S_IFSOCK
+ 0140000
+
+	)
+
+289 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+290 

+	#S_IFWHT
+ 0160000
+
+	)
+
+291 

+	#S_IFXATTR
+ 0200000
+
+	)
+
+296 

+	#S_IRWXU
+ 0000700
+
+	)
+
+297 

+	#S_IRUSR
+ 0000400
+
+	)
+
+298 

+	#S_IWUSR
+ 0000200
+
+	)
+
+299 

+	#S_IXUSR
+ 0000100
+
+	)
+
+301 

+	#S_IRWXG
+ 0000070
+
+	)
+
+302 

+	#S_IRGRP
+ 0000040
+
+	)
+
+303 

+	#S_IWGRP
+ 0000020
+
+	)
+
+304 

+	#S_IXGRP
+ 0000010
+
+	)
+
+306 

+	#S_IRWXO
+ 0000007
+
+	)
+
+307 

+	#S_IROTH
+ 0000004
+
+	)
+
+308 

+	#S_IWOTH
+ 0000002
+
+	)
+
+309 

+	#S_IXOTH
+ 0000001
+
+	)
+
+311 

+	#S_ISUID
+ 0004000
+
+	)
+
+312 

+	#S_ISGID
+ 0002000
+
+	)
+
+313 

+	#S_ISVTX
+ 0001000
+
+	)
+
+315 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+316 

+	#S_ISTXT
+ 
+S_ISVTX
+
+
+	)
+
+317 

+	#S_IREAD
+ 
+S_IRUSR
+
+
+	)
+
+318 

+	#S_IWRITE
+ 
+S_IWUSR
+
+
+	)
+
+319 

+	#S_IEXEC
+ 
+S_IXUSR
+
+
+	)
+
+329 

+	#S_ISBLK
+(
+m
+�(((m�& 0170000�=�0060000�
+
+	)
+
+330 

+	#S_ISCHR
+(
+m
+�(((m�& 0170000�=�0020000�
+
+	)
+
+331 

+	#S_ISDIR
+(
+m
+�(((m�& 0170000�=�0040000�
+
+	)
+
+332 

+	#S_ISFIFO
+(
+m
+�(((m�& 0170000�=�0010000�
+
+	)
+
+333 

+	#S_ISREG
+(
+m
+�(((m�& 0170000�=�0100000�
+
+	)
+
+334 

+	#S_ISLNK
+(
+m
+�(((m�& 0170000�=�0120000�
+
+	)
+
+335 

+	#S_ISSOCK
+(
+m
+�(((m�& 0170000�=�0140000�
+
+	)
+
+336 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+337 

+	#S_ISWHT
+(
+m
+�(((m�& 0170000�=�0160000�
+
+	)
+
+338 

+	#S_ISXATTR
+(
+m
+�(((m�& 0200000�=�0200000�
+
+	)
+
+356 

+	#S_TYPEISMQ
+(
+buf
+�(0�
+
+	)
+
+357 

+	#S_TYPEISSEM
+(
+buf
+�(0�
+
+	)
+
+358 

+	#S_TYPEISSHM
+(
+buf
+�(0�
+
+	)
+
+374 

+	#S_TYPEISTMO
+(
+buf
+�(0�
+
+	)
+
+377 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+378 

+	#ACCESSPERMS
+ (
+S_IRWXU
+|
+S_IRWXG
+|
+S_IRWXO
+�
+
+	)
+
+380 

+	#ALLPERMS
+ (
+S_ISUID
+|
+S_ISGID
+|
+S_ISTXT
+|
+S_IRWXU
+|
+S_IRWXG
+|
+S_IRWXO
+)
+
+	)
+
+382 

+	#DEFFILEMODE
+ (
+S_IRUSR
+|
+S_IWUSR
+|
+S_IRGRP
+|
+S_IWGRP
+|
+S_IROTH
+|
+S_IWOTH
+)
+
+	)
+
+384 

+	#S_BLKSIZE
+ 512
+
+	)
+
+391 

+	#UF_SETTABLE
+ 0x0000fff�
+
+	)
+
+392 

+	#UF_NODUMP
+ 0x00000001
+
+	)
+
+393 

+	#UF_IMMUTABLE
+ 0x00000002
+
+	)
+
+394 

+	#UF_APPEND
+ 0x00000004
+
+	)
+
+395 

+	#UF_OPAQUE
+ 0x00000008
+
+	)
+
+402 

+	#UF_HIDDEN
+ 0x00008000
+
+	)
+
+407 

+	#SF_SETTABLE
+ 0xffff0000
+
+	)
+
+408 

+	#SF_ARCHIVED
+ 0x00010000
+
+	)
+
+409 

+	#SF_IMMUTABLE
+ 0x00020000
+
+	)
+
+410 

+	#SF_APPEND
+ 0x00040000
+
+	)
+
+422 
+__BEGIN_DECLS
+
+
+424 
+	$chmod
+(cڡ *, 
+mode_t
+�
+	`__DARWIN_ALIAS
+(
+chmod
+);
+
+425 
+	$fchmod
+(, 
+mode_t
+�
+	`__DARWIN_ALIAS
+(
+fchmod
+);
+
+426 
+	$f��
+(, 
+��
+ *�
+	`__DARWIN_INODE64
+(
+f��
+);
+
+427 
+	$l��
+(cڡ *, 
+��
+ *�
+	`__DARWIN_INODE64
+(
+l��
+);
+
+428 
+	`mkd�
+(cڡ *, 
+mode_t
+);
+
+429 
+	`mkfifo
+(cڡ *, 
+mode_t
+);
+
+430 
+	$��
+(cڡ *, 
+��
+ *�
+	`__DARWIN_INODE64
+(stat);
+
+431 
+	`mknod
+(cڡ *, 
+mode_t
+, 
+dev_t
+);
+
+432 
+mode_t
+ 
+	`umask
+(mode_t);
+
+434 #i�!
+	`def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+435 #i�de�
+_FILESEC_T
+
+
+436 
+_f�e�c
+;
+
+437 
+_f�e�c
+ *
+	tf�e�c_t
+;
+
+438 

+	#_FILESEC_T
+
+
+	)
+
+440 
+	`ch�ags
+(cڡ *, 
+__u�t32_t
+);
+
+441 
+	`chmodx_�
+(cڡ *, 
+f�e�c_t
+);
+
+442 
+	`fch�ags
+(, 
+__u�t32_t
+);
+
+443 
+	`fchmodx_�
+(, 
+f�e�c_t
+);
+
+444 
+	$f��x_�
+(, 
+��
+ *, 
+f�e�c_t
+�
+	`__DARWIN_INODE64
+(
+f��x_�
+);
+
+445 
+	`lch�ags
+(cڡ *, 
+__u�t32_t
+);
+
+446 
+	`lchmod
+(cڡ *, 
+mode_t
+);
+
+447 
+	$l��x_�
+(cڡ *, 
+��
+ *, 
+f�e�c_t
+�
+	`__DARWIN_INODE64
+(
+l��x_�
+);
+
+448 
+	`mkd�x_�
+(cڡ *, 
+f�e�c_t
+);
+
+449 
+	`mkfifox_�
+(cڡ *, 
+f�e�c_t
+);
+
+450 
+	$��x_�
+(cڡ *, 
+��
+ *, 
+f�e�c_t
+�
+	`__DARWIN_INODE64
+(
+��x_�
+);
+
+451 
+	`umaskx_�
+(
+f�e�c_t
+);
+
+453 
+	`f��x64_�
+(, 
+��64
+ *, 
+f�e�c_t
+);
+
+454 
+	`l��x64_�
+(cڡ *, 
+��64
+ *, 
+f�e�c_t
+);
+
+455 
+	`��x64_�
+(cڡ *, 
+��64
+ *, 
+f�e�c_t
+);
+
+456 
+	`f��64
+(, 
+��64
+ *);
+
+457 
+	`l��64
+(cڡ *, 
+��64
+ *);
+
+458 
+	`��64
+(cڡ *, 
+��64
+ *);
+
+461 
+__END_DECLS
+
+
+	@/usr/include/sys/time.h
+
+64 #i�de�
+_SYS_TIME_H_
+
+
+65 

+	#_SYS_TIME_H_
+
+
+	)
+
+67 
+	~<sys/cdefs.h
+>
+
+68 
+	~<sys/_ty�s.h
+>
+
+74 

+	#__�ed_fd_�t
+
+
+	)
+
+75 

+	#__�ed_�ru�_time�ec
+
+
+	)
+
+76 

+	#__�ed_�ru�_timev�
+
+
+	)
+
+77 
+	~<sys/_�ru�s.h
+>
+
+79 #i�def 
+_TIME_T
+
+
+80 

+	#_TIME_T
+
+
+	)
+
+81 
+__d�w�_time_t
+ 
+	ttime_t
+;
+
+84 #i�de�
+_SUSECONDS_T
+
+
+85 

+	#_SUSECONDS_T
+
+
+	)
+
+86 
+__d�w�_su�c�ds_t
+ 
+	tsu�c�ds_t
+;
+
+93 
+	s�im�v�
+ {
+
+94 
+timev�
+ 
+	m�_��rv�
+;
+
+95 
+timev�
+ 
+	m�_v�ue
+;
+
+102 

+	#ITIMER_REAL
+ 0
+
+	)
+
+103 

+	#ITIMER_VIRTUAL
+ 1
+
+	)
+
+104 

+	#ITIMER_PROF
+ 2
+
+	)
+
+112 #i�def 
+FD_SETSIZE
+
+
+113 

+	#FD_SETSIZE
+ 
+__DARWIN_FD_SETSIZE
+
+
+	)
+
+115 #i�de�
+FD_SET
+
+
+116 

+	#FD_SET
+(
+n
+, 
+p
+�
+	`__DARWIN_FD_SET
+�,�)
+
+	)
+
+118 #i�def 
+FD_CLR
+
+
+119 

+	#FD_CLR
+(
+n
+,
+p
+�
+	`__DARWIN_FD_CLR
+�,�)
+
+	)
+
+121 #i�de�
+FD_ISSET
+
+
+122 

+	#FD_ISSET
+(
+n
+, 
+p
+�
+	`__DARWIN_FD_ISSET
+�,�)
+
+	)
+
+124 #i�de�
+FD_ZERO
+
+
+125 

+	#FD_ZERO
+(
+p
+�
+	`__DARWIN_FD_ZERO
+�)
+
+	)
+
+128 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+130 #i�de�
+FD_COPY
+
+
+131 

+	#FD_COPY
+(
+f
+, 
+t
+�
+	`__DARWIN_FD_COPY
+(f,�)
+
+	)
+
+135 

+	#TIMEVAL_TO_TIMESPEC
+(
+tv
+, 
+ts
+) { \
+
+136 (
+ts
+)->
+tv_�c
+ = (
+tv
+)->tv_sec; \
+
+137 (
+ts
+)->
+tv_n�c
+ = (
+tv
+)->
+tv_u�c
+ * 1000; \
+
+138 }
+
+	)
+
+139 

+	#TIMESPEC_TO_TIMEVAL
+(
+tv
+, 
+ts
+) { \
+
+140 (
+tv
+)->
+tv_�c
+ = (
+ts
+)->tv_sec; \
+
+141 (
+tv
+)->
+tv_u�c
+ = (
+ts
+)->
+tv_n�c
+ / 1000; \
+
+142 }
+
+	)
+
+144 
+	stimez�e
+ {
+
+145 
+	mtz_m�u�swe�
+;
+
+146 
+	mtz_d�time
+;
+
+148 

+	#DST_NONE
+ 0
+
+	)
+
+149 

+	#DST_USA
+ 1
+
+	)
+
+150 

+	#DST_AUST
+ 2
+
+	)
+
+151 

+	#DST_WET
+ 3
+
+	)
+
+152 

+	#DST_MET
+ 4
+
+	)
+
+153 

+	#DST_EET
+ 5
+
+	)
+
+154 

+	#DST_CAN
+ 6
+
+	)
+
+157 

+	#tim���r
+(
+tvp
+��vp)->
+tv_�c
+ = (tvp)->
+tv_u�c
+ = 0
+
+	)
+
+158 

+	#tim�is�t
+(
+tvp
+�(�vp)->
+tv_�c
+ || (tvp)->
+tv_u�c
+)
+
+	)
+
+159 

+	#tim�cmp
+(
+tvp
+, 
+uvp
+, 
+cmp
+) \
+
+160 (((
+tvp
+)->
+tv_�c
+ =�(
+uvp
+)->tv_sec) ? \
+
+161 ((
+tvp
+)->
+tv_u�c
+ 
+	`cmp
+ (
+uvp
+)->tv_usec) : \
+
+162 ((
+tvp
+)->
+tv_�c
+ 
+	`cmp
+ (
+uvp
+)->tv_�c))
+
+	)
+
+163 

+	#tim�add
+(
+tvp
+, 
+uvp
+, 
+vvp
+) \
+
+165 (
+vvp
+)->
+tv_�c
+ = (
+tvp
+)->tv_��+ (
+uvp
+)->tv_sec; \
+
+166 (
+vvp
+)->
+tv_u�c
+ = (
+tvp
+)->tv_u��+ (
+uvp
+)->tv_usec; \
+
+167 i�((
+vvp
+)->
+tv_u�c
+ >= 1000000) { \
+
+168 (
+vvp
+)->
+tv_�c
+++; \
+
+169 (
+vvp
+)->
+tv_u�c
+ -= 1000000; \
+
+171 } 0)
+
+	)
+
+172 

+	#tim�sub
+(
+tvp
+, 
+uvp
+, 
+vvp
+) \
+
+174 (
+vvp
+)->
+tv_�c
+ = (
+tvp
+)->tv_��- (
+uvp
+)->tv_sec; \
+
+175 (
+vvp
+)->
+tv_u�c
+ = (
+tvp
+)->tv_u��- (
+uvp
+)->tv_usec; \
+
+176 i�((
+vvp
+)->
+tv_u�c
+ < 0) { \
+
+177 (
+vvp
+)->
+tv_�c
+--; \
+
+178 (
+vvp
+)->
+tv_u�c
+ += 1000000; \
+
+180 } 0)
+
+	)
+
+182 

+	#timev�cmp
+(
+l
+, 
+r
+, 
+cmp
+�
+	`tim�cmp
+�,�, cmp�
+
+	)
+
+187 
+	s�ock�fo
+ {
+
+188 
+	mhz
+;
+
+189 
+	mtick
+;
+
+190 
+	mtickadj
+;
+
+191 
+	m��hz
+;
+
+192 
+	m�ofhz
+;
+
+197 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+198 
+	~<time.h
+>
+
+201 
+	g__BEGIN_DECLS
+
+
+203 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+204 
+adjtime
+(cڡ 
+timev�
+ *, timeval *);
+
+205 
+futimes
+(, cڡ 
+timev�
+ *);
+
+206 
+lutimes
+(cڡ *, cڡ 
+timev�
+ *);
+
+207 
+��imeofday
+(cڡ 
+timev�
+ *, cڡ 
+timez�e
+ *);
+
+210 
+g��im�
+(, 
+�im�v�
+ *);
+
+211 
+g�timeofday
+(
+timev�
+ * 
+__��ri�
+, * __restrict);
+
+213 
+	~<sys/_���.h
+>
+
+215 
+�t�im�
+(, cڡ 
+�im�v�
+ * 
+__��ri�
+,
+
+216 
+�im�v�
+ * 
+__��ri�
+);
+
+217 
+utimes
+(cڡ *, cڡ 
+timev�
+ *);
+
+219 
+	g__END_DECLS
+
+
+	@/usr/include/sys/types.h
+
+69 #i�de�
+_SYS_TYPES_H_
+
+
+70 

+	#_SYS_TYPES_H_
+
+
+	)
+
+72 
+	~<sys/���pi�ts.h
+>
+
+74 #i�de�
+__ASSEMBLER__
+
+
+75 
+	~<sys/cdefs.h
+>
+
+78 
+	~<mach�e/ty�s.h
+>
+
+79 
+	~<sys/_ty�s.h
+>
+
+81 
+	~<mach�e/�d�n.h
+>
+
+83 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+84 
+	tu_ch�
+;
+
+85 
+	tu_sh�t
+;
+
+86 
+	tu_�t
+;
+
+87 #i�de�
+_U_LONG
+
+
+88 
+	tu_l�g
+;
+
+89 

+	#_U_LONG
+
+
+	)
+
+91 
+	tush�t
+;
+
+92 
+	tu�t
+;
+
+95 
+u_�t64_t
+ 
+	tu_quad_t
+;
+
+96 
+�t64_t
+ 
+	tquad_t
+;
+
+97 
+quad_t
+ * 
+	tqaddr_t
+;
+
+99 * 
+	t�ddr_t
+;
+
+100 
+�t32_t
+ 
+	tdaddr_t
+;
+
+102 #i�de�
+_DEV_T
+
+
+103 
+__d�w�_dev_t
+ 
+	tdev_t
+;
+
+104 

+	#_DEV_T
+
+
+	)
+
+107 
+u_�t32_t
+ 
+	tfix�_t
+;
+
+109 #i�de�
+_BLKCNT_T
+
+
+110 
+__d�w�_blk�t_t
+ 
+	tblk�t_t
+;
+
+111 

+	#_BLKCNT_T
+
+
+	)
+
+114 #i�de�
+_BLKSIZE_T
+
+
+115 
+__d�w�_blksize_t
+ 
+	tblksize_t
+;
+
+116 

+	#_BLKSIZE_T
+
+
+	)
+
+119 #i�de�
+_GID_T
+
+
+120 
+__d�w�_gid_t
+ 
+	tgid_t
+;
+
+121 

+	#_GID_T
+
+
+	)
+
+124 #i�de�
+_IN_ADDR_T
+
+
+125 

+	#_IN_ADDR_T
+
+
+	)
+
+126 
+__u�t32_t
+ 
+	t�_addr_t
+;
+
+129 #i�de�
+_IN_PORT_T
+
+
+130 

+	#_IN_PORT_T
+
+
+	)
+
+131 
+__u�t16_t
+ 
+	t�_p�t_t
+;
+
+134 #i�def 
+_INO_T
+
+
+135 
+__d�w�_�o_t
+ 
+	t�o_t
+;
+
+136 

+	#_INO_T
+
+
+	)
+
+139 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+140 #i�def 
+_INO64_T
+
+
+141 
+__d�w�_�o64_t
+ 
+	t�o64_t
+;
+
+142 

+	#_INO64_T
+
+
+	)
+
+146 #i�de�
+_KEY_T
+
+
+147 

+	#_KEY_T
+
+
+	)
+
+148 
+__�t32_t
+ 
+	tkey_t
+;
+
+151 #i�def 
+_MODE_T
+
+
+152 
+__d�w�_mode_t
+ 
+	tmode_t
+;
+
+153 

+	#_MODE_T
+
+
+	)
+
+156 #i�de�
+_NLINK_T
+
+
+157 
+__u�t16_t
+ 
+	tƚk_t
+;
+
+158 

+	#_NLINK_T
+
+
+	)
+
+161 #i�de�
+_ID_T
+
+
+162 

+	#_ID_T
+
+
+	)
+
+163 
+__d�w�_id_t
+ 
+	tid_t
+;
+
+166 #i�de�
+_PID_T
+
+
+167 
+__d�w�_pid_t
+ 
+	tpid_t
+;
+
+168 

+	#_PID_T
+
+
+	)
+
+171 #i�de�
+_OFF_T
+
+
+172 
+__d�w�_off_t
+ 
+	toff_t
+;
+
+173 

+	#_OFF_T
+
+
+	)
+
+176 
+�t32_t
+ 
+	t�gsz_t
+;
+
+177 
+�t32_t
+ 
+	tswblk_t
+;
+
+179 #i�de�
+_UID_T
+
+
+180 
+__d�w�_uid_t
+ 
+	tuid_t
+;
+
+181 

+	#_UID_T
+
+
+	)
+
+184 #i�de�
+_ID_T
+
+
+185 
+__d�w�_id_t
+ 
+	tid_t
+;
+
+186 

+	#_ID_T
+
+
+	)
+
+189 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+191 #i�
+def�ed
+(
+__�lu�lus
+)
+
+197 
+�l�e
+ 
+__�t32_t
+ 
+	$maj�
+(
+__u�t32_t
+ 
+_x
+)
+
+199  (
+__�t32_t
+)(((
+__u�t32_t
+)
+_x
+ >> 24) & 0xff);
+
+200 
+	}
+}
+
+202 
+�l�e
+ 
+__�t32_t
+ 
+	$m��
+(
+__u�t32_t
+ 
+_x
+)
+
+204  (
+__�t32_t
+)((
+_x
+) & 0xffffff);
+
+205 
+	}
+}
+
+207 
+�l�e
+ 
+dev_t
+ 
+	$makedev
+(
+__u�t32_t
+ 
+_maj�
+, __u�t32_�
+_m��
+)
+
+209  (
+dev_t
+)(((
+_maj�
+�<< 24�| (
+_m��
+));
+
+210 
+	}
+}
+
+214 

+	#maj�
+(
+x
+�((
+�t32_t
+)(((
+u_�t32_t
+)(x�>> 24�& 0xff))
+
+	)
+
+215 

+	#m��
+(
+x
+�((
+�t32_t
+)((x�& 0xffffff))
+
+	)
+
+216 

+	#makedev
+(
+x
+,
+y
+�((
+dev_t
+)(((x�<< 24�| (y)))
+
+	)
+
+221 #i�def 
+_CLOCK_T
+
+
+222 

+	#_CLOCK_T
+
+
+	)
+
+223 
+__d�w�_�ock_t
+ 
+	t�ock_t
+;
+
+226 #i�de�
+_SIZE_T
+
+
+227 

+	#_SIZE_T
+
+
+	)
+
+230 
+__d�w�_size_t
+ 
+	tsize_t
+;
+
+233 #i�def 
+_SSIZE_T
+
+
+234 

+	#_SSIZE_T
+
+
+	)
+
+235 
+__d�w�_ssize_t
+ 
+	tssize_t
+;
+
+238 #i�def 
+_TIME_T
+
+
+239 

+	#_TIME_T
+
+
+	)
+
+240 
+__d�w�_time_t
+ 
+	ttime_t
+;
+
+243 #i�de�
+_USECONDS_T
+
+
+244 

+	#_USECONDS_T
+
+
+	)
+
+245 
+__d�w�_u�c�ds_t
+ 
+	tu�c�ds_t
+;
+
+248 #i�de�
+_SUSECONDS_T
+
+
+249 

+	#_SUSECONDS_T
+
+
+	)
+
+250 
+__d�w�_su�c�ds_t
+ 
+	tsu�c�ds_t
+;
+
+253 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+259 

+	#__�ed_fd_�t
+
+
+	)
+
+260 
+	~<sys/_�ru�s.h
+>
+
+262 

+	#NBBY
+ 
+__DARWIN_NBBY
+
+
+	)
+
+263 

+	#NFDBITS
+ 
+__DARWIN_NFDBITS
+
+
+	)
+
+264 

+	#howm�y
+(
+x
+, 
+y
+�
+	`__DARWIN_howm�y
+(x, y�
+
+	)
+
+265 
+__�t32_t
+ 
+	tfd_mask
+;
+
+273 #i�def 
+FD_SETSIZE
+
+
+274 

+	#FD_SETSIZE
+ 
+__DARWIN_FD_SETSIZE
+
+
+	)
+
+276 #i�de�
+FD_SET
+
+
+277 

+	#FD_SET
+(
+n
+, 
+p
+�
+	`__DARWIN_FD_SET
+�,�)
+
+	)
+
+279 #i�de�
+FD_CLR
+
+
+280 

+	#FD_CLR
+(
+n
+, 
+p
+�
+	`__DARWIN_FD_CLR
+�,�)
+
+	)
+
+282 #i�de�
+FD_ISSET
+
+
+283 

+	#FD_ISSET
+(
+n
+, 
+p
+�
+	`__DARWIN_FD_ISSET
+�,�)
+
+	)
+
+285 #i�de�
+FD_ZERO
+
+
+286 

+	#FD_ZERO
+(
+p
+�
+	`__DARWIN_FD_ZERO
+�)
+
+	)
+
+288 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+289 #i�de�
+FD_COPY
+
+
+290 

+	#FD_COPY
+(
+f
+, 
+t
+�
+	`__DARWIN_FD_COPY
+(f,�)
+
+	)
+
+295 #i�
+def�ed
+(
+__STDC__
+�&& def�ed(
+KERNEL
+)
+
+301 
+	g�oc
+;
+
+302 
+	gpg�
+;
+
+303 
+	gu�ed
+;
+
+304 
+	gru�ge
+;
+
+305 
+	gf�e
+;
+
+306 
+	gbuf
+;
+
+307 
+	g�y
+;
+
+308 
+	guio
+;
+
+314 #i�de�
+__POSIX_LIB__
+
+
+316 #i�de�
+_PTHREAD_ATTR_T
+
+
+317 

+	#_PTHREAD_ATTR_T
+
+
+	)
+
+318 
+__d�w�_�h�ad_��_t
+ 
+	t�h�ad_��_t
+;
+
+320 #i�de�
+_PTHREAD_COND_T
+
+
+321 

+	#_PTHREAD_COND_T
+
+
+	)
+
+322 
+__d�w�_�h�ad_c�d_t
+ 
+	t�h�ad_c�d_t
+;
+
+324 #i�de�
+_PTHREAD_CONDATTR_T
+
+
+325 

+	#_PTHREAD_CONDATTR_T
+
+
+	)
+
+326 
+__d�w�_�h�ad_c�d��_t
+ 
+	t�h�ad_c�d��_t
+;
+
+328 #i�de�
+_PTHREAD_MUTEX_T
+
+
+329 

+	#_PTHREAD_MUTEX_T
+
+
+	)
+
+330 
+__d�w�_�h�ad_mu�x_t
+ 
+	t�h�ad_mu�x_t
+;
+
+332 #i�de�
+_PTHREAD_MUTEXATTR_T
+
+
+333 

+	#_PTHREAD_MUTEXATTR_T
+
+
+	)
+
+334 
+__d�w�_�h�ad_mu�x��_t
+ 
+	t�h�ad_mu�x��_t
+;
+
+336 #i�de�
+_PTHREAD_ONCE_T
+
+
+337 

+	#_PTHREAD_ONCE_T
+
+
+	)
+
+338 
+__d�w�_�h�ad_��_t
+ 
+	t�h�ad_��_t
+;
+
+340 #i�de�
+_PTHREAD_RWLOCK_T
+
+
+341 

+	#_PTHREAD_RWLOCK_T
+
+
+	)
+
+342 
+__d�w�_�h�ad_rwlock_t
+ 
+	t�h�ad_rwlock_t
+;
+
+344 #i�de�
+_PTHREAD_RWLOCKATTR_T
+
+
+345 

+	#_PTHREAD_RWLOCKATTR_T
+
+
+	)
+
+346 
+__d�w�_�h�ad_rwlock��_t
+ 
+	t�h�ad_rwlock��_t
+;
+
+348 #i�de�
+_PTHREAD_T
+
+
+349 

+	#_PTHREAD_T
+
+
+	)
+
+350 
+__d�w�_�h�ad_t
+ 
+	t�h�ad_t
+;
+
+355 #i�de�
+_PTHREAD_KEY_T
+
+
+356 

+	#_PTHREAD_KEY_T
+
+
+	)
+
+357 
+__d�w�_�h�ad_key_t
+ 
+	t�h�ad_key_t
+;
+
+361 #i�de�
+_FSBLKCNT_T
+
+
+362 

+	#_FSBLKCNT_T
+
+
+	)
+
+363 
+__d�w�_fsblk�t_t
+ 
+	tfsblk�t_t
+;
+
+366 #i�de�
+_FSFILCNT_T
+
+
+367 

+	#_FSFILCNT_T
+
+
+	)
+
+368 
+__d�w�_fsf��t_t
+ 
+	tfsf��t_t
+;
+
+	@/usr/include/unistd.h
+
+68 #i�de�
+_UNISTD_H_
+
+
+69 

+	#_UNISTD_H_
+
+
+	)
+
+71 
+	~<_ty�s.h
+>
+
+72 
+	~<sys/uni�d.h
+>
+
+74 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+75 #i�de�
+_DEV_T
+
+
+76 

+	#_DEV_T
+
+
+	)
+
+77 
+__d�w�_dev_t
+ 
+	tdev_t
+;
+
+81 #i�de�
+_GID_T
+
+
+82 

+	#_GID_T
+
+
+	)
+
+83 
+__d�w�_gid_t
+ 
+	tgid_t
+;
+
+86 #i�de�
+_INTPTR_T
+
+
+87 

+	#_INTPTR_T
+
+
+	)
+
+88 
+__d�w�_���_t
+ 
+	t���_t
+;
+
+91 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+92 #i�de�
+_MODE_T
+
+
+93 

+	#_MODE_T
+
+
+	)
+
+94 
+__d�w�_mode_t
+ 
+	tmode_t
+;
+
+98 #i�de�
+_OFF_T
+
+
+99 

+	#_OFF_T
+
+
+	)
+
+100 
+__d�w�_off_t
+ 
+	toff_t
+;
+
+103 #i�de�
+_PID_T
+
+
+104 

+	#_PID_T
+
+
+	)
+
+105 
+__d�w�_pid_t
+ 
+	tpid_t
+;
+
+108 #i�de�
+_SIZE_T
+
+
+109 

+	#_SIZE_T
+
+
+	)
+
+112 
+__d�w�_size_t
+ 
+	tsize_t
+;
+
+115 #i�def 
+_SSIZE_T
+
+
+116 

+	#_SSIZE_T
+
+
+	)
+
+117 
+__d�w�_ssize_t
+ 
+	tssize_t
+;
+
+120 #i�de�
+_UID_T
+
+
+121 

+	#_UID_T
+
+
+	)
+
+122 
+__d�w�_uid_t
+ 
+	tuid_t
+;
+
+125 #i�de�
+_USECONDS_T
+
+
+126 

+	#_USECONDS_T
+
+
+	)
+
+127 
+__d�w�_u�c�ds_t
+ 
+	tu�c�ds_t
+;
+
+130 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+131 #i�de�
+_UUID_T
+
+
+132 

+	#_UUID_T
+
+
+	)
+
+133 
+__d�w�_uuid_t
+ 
+	tuuid_t
+;
+
+137 

+	#STDIN_FILENO
+ 0
+
+	)
+
+138 

+	#STDOUT_FILENO
+ 1
+
+	)
+
+139 

+	#STDERR_FILENO
+ 2
+
+	)
+
+141 #i�de�
+NULL
+
+
+142 

+	#NULL
+ 
+__DARWIN_NULL
+
+
+	)
+
+147 

+	#_XOPEN_VERSION
+ 600
+
+	)
+
+148 

+	#_XOPEN_XCU_VERSION
+ 4
+
+	)
+
+152 

+	#_POSIX_ADVISORY_INFO
+ (-1�
+
+	)
+
+153 

+	#_POSIX_ASYNCHRONOUS_IO
+ (-1�
+
+	)
+
+154 

+	#_POSIX_BARRIERS
+ (-1�
+
+	)
+
+155 

+	#_POSIX_CHOWN_RESTRICTED
+ 200112L
+
+	)
+
+156 

+	#_POSIX_CLOCK_SELECTION
+ (-1�
+
+	)
+
+157 

+	#_POSIX_CPUTIME
+ (-1�
+
+	)
+
+158 

+	#_POSIX_FSYNC
+ 200112L
+
+	)
+
+159 

+	#_POSIX_IPV6
+ 200112L
+
+	)
+
+160 

+	#_POSIX_JOB_CONTROL
+ 200112L
+
+	)
+
+161 

+	#_POSIX_MAPPED_FILES
+ 200112L
+
+	)
+
+162 

+	#_POSIX_MEMLOCK
+ (-1�
+
+	)
+
+163 

+	#_POSIX_MEMLOCK_RANGE
+ (-1�
+
+	)
+
+164 

+	#_POSIX_MEMORY_PROTECTION
+ 200112L
+
+	)
+
+165 

+	#_POSIX_MESSAGE_PASSING
+ (-1�
+
+	)
+
+166 

+	#_POSIX_MONOTONIC_CLOCK
+ (-1�
+
+	)
+
+167 

+	#_POSIX_NO_TRUNC
+ 200112L
+
+	)
+
+168 

+	#_POSIX_PRIORITIZED_IO
+ (-1�
+
+	)
+
+169 

+	#_POSIX_PRIORITY_SCHEDULING
+ (-1�
+
+	)
+
+170 

+	#_POSIX_RAW_SOCKETS
+ (-1�
+
+	)
+
+171 

+	#_POSIX_READER_WRITER_LOCKS
+ 200112L
+
+	)
+
+172 

+	#_POSIX_REALTIME_SIGNALS
+ (-1�
+
+	)
+
+173 

+	#_POSIX_REGEXP
+ 200112L
+
+	)
+
+174 

+	#_POSIX_SAVED_IDS
+ 200112L
+
+	)
+
+175 

+	#_POSIX_SEMAPHORES
+ (-1�
+
+	)
+
+176 

+	#_POSIX_SHARED_MEMORY_OBJECTS
+ (-1�
+
+	)
+
+177 

+	#_POSIX_SHELL
+ 200112L
+
+	)
+
+178 

+	#_POSIX_SPAWN
+ (-1�
+
+	)
+
+179 

+	#_POSIX_SPIN_LOCKS
+ (-1�
+
+	)
+
+180 

+	#_POSIX_SPORADIC_SERVER
+ (-1�
+
+	)
+
+181 

+	#_POSIX_SYNCHRONIZED_IO
+ (-1�
+
+	)
+
+182 

+	#_POSIX_THREAD_ATTR_STACKADDR
+ 200112L
+
+	)
+
+183 

+	#_POSIX_THREAD_ATTR_STACKSIZE
+ 200112L
+
+	)
+
+184 

+	#_POSIX_THREAD_CPUTIME
+ (-1�
+
+	)
+
+185 

+	#_POSIX_THREAD_PRIO_INHERIT
+ (-1�
+
+	)
+
+186 

+	#_POSIX_THREAD_PRIO_PROTECT
+ (-1�
+
+	)
+
+187 

+	#_POSIX_THREAD_PRIORITY_SCHEDULING
+ (-1�
+
+	)
+
+188 

+	#_POSIX_THREAD_PROCESS_SHARED
+ 200112L
+
+	)
+
+189 

+	#_POSIX_THREAD_SAFE_FUNCTIONS
+ 200112L
+
+	)
+
+190 

+	#_POSIX_THREAD_SPORADIC_SERVER
+ (-1�
+
+	)
+
+191 

+	#_POSIX_THREADS
+ 200112L
+
+	)
+
+192 

+	#_POSIX_TIMEOUTS
+ (-1�
+
+	)
+
+193 

+	#_POSIX_TIMERS
+ (-1�
+
+	)
+
+194 

+	#_POSIX_TRACE
+ (-1�
+
+	)
+
+195 

+	#_POSIX_TRACE_EVENT_FILTER
+ (-1�
+
+	)
+
+196 

+	#_POSIX_TRACE_INHERIT
+ (-1�
+
+	)
+
+197 

+	#_POSIX_TRACE_LOG
+ (-1�
+
+	)
+
+198 

+	#_POSIX_TYPED_MEMORY_OBJECTS
+ (-1�
+
+	)
+
+199 #i�de�
+_POSIX_VDISABLE
+
+
+200 

+	#_POSIX_VDISABLE
+ 0xf�
+
+	)
+
+203 

+	#_POSIX2_C_BIND
+ 200112L
+
+	)
+
+204 

+	#_POSIX2_C_DEV
+ 200112L
+
+	)
+
+205 

+	#_POSIX2_CHAR_TERM
+ 200112L
+
+	)
+
+206 

+	#_POSIX2_FORT_DEV
+ (-1�
+
+	)
+
+207 

+	#_POSIX2_FORT_RUN
+ 200112L
+
+	)
+
+208 

+	#_POSIX2_LOCALEDEF
+ 200112L
+
+	)
+
+209 

+	#_POSIX2_PBS
+ (-1)
+
+	)
+
+210 

+	#_POSIX2_PBS_ACCOUNTING
+ (-1)
+
+	)
+
+211 

+	#_POSIX2_PBS_CHECKPOINT
+ (-1)
+
+	)
+
+212 

+	#_POSIX2_PBS_LOCATE
+ (-1)
+
+	)
+
+213 

+	#_POSIX2_PBS_MESSAGE
+ (-1)
+
+	)
+
+214 

+	#_POSIX2_PBS_TRACK
+ (-1)
+
+	)
+
+215 

+	#_POSIX2_SW_DEV
+ 200112L
+
+	)
+
+216 

+	#_POSIX2_UPE
+ 200112L
+
+	)
+
+218 

+	#_V6_ILP32_OFF32
+ (-1)
+
+	)
+
+219 

+	#_V6_ILP32_OFFBIG
+ (1)
+
+	)
+
+220 

+	#_V6_LP64_OFF64
+ (-1)
+
+	)
+
+221 

+	#_V6_LPBIG_OFFBIG
+ (-1)
+
+	)
+
+223 

+	#_XBS5_ILP32_OFF32
+ 
+_V6_ILP32_OFF32
+
+
+	)
+
+224 

+	#_XBS5_ILP32_OFFBIG
+ 
+_V6_ILP32_OFFBIG
+
+
+	)
+
+225 

+	#_XBS5_LP64_OFF64
+ 
+_V6_LP64_OFF64
+
+
+	)
+
+226 

+	#_XBS5_LPBIG_OFFBIG
+ 
+_V6_LPBIG_OFFBIG
+
+
+	)
+
+228 

+	#_XOPEN_CRYPT
+ (1)
+
+	)
+
+229 

+	#_XOPEN_ENH_I18N
+ (1�
+
+	)
+
+230 

+	#_XOPEN_LEGACY
+ (-1�
+
+	)
+
+231 

+	#_XOPEN_REALTIME
+ (-1�
+
+	)
+
+232 

+	#_XOPEN_REALTIME_THREADS
+ (-1�
+
+	)
+
+233 

+	#_XOPEN_SHM
+ (1)
+
+	)
+
+234 

+	#_XOPEN_STREAMS
+ (-1)
+
+	)
+
+235 

+	#_XOPEN_UNIX
+ (1)
+
+	)
+
+238 

+	#F_ULOCK
+ 0
+
+	)
+
+239 

+	#F_LOCK
+ 1
+
+	)
+
+240 

+	#F_TLOCK
+ 2
+
+	)
+
+241 

+	#F_TEST
+ 3
+
+	)
+
+244 

+	#_SC_ARG_MAX
+ 1
+
+	)
+
+245 

+	#_SC_CHILD_MAX
+ 2
+
+	)
+
+246 

+	#_SC_CLK_TCK
+ 3
+
+	)
+
+247 

+	#_SC_NGROUPS_MAX
+ 4
+
+	)
+
+248 

+	#_SC_OPEN_MAX
+ 5
+
+	)
+
+249 

+	#_SC_JOB_CONTROL
+ 6
+
+	)
+
+250 

+	#_SC_SAVED_IDS
+ 7
+
+	)
+
+251 

+	#_SC_VERSION
+ 8
+
+	)
+
+252 

+	#_SC_BC_BASE_MAX
+ 9
+
+	)
+
+253 

+	#_SC_BC_DIM_MAX
+ 10
+
+	)
+
+254 

+	#_SC_BC_SCALE_MAX
+ 11
+
+	)
+
+255 

+	#_SC_BC_STRING_MAX
+ 12
+
+	)
+
+256 

+	#_SC_COLL_WEIGHTS_MAX
+ 13
+
+	)
+
+257 

+	#_SC_EXPR_NEST_MAX
+ 14
+
+	)
+
+258 

+	#_SC_LINE_MAX
+ 15
+
+	)
+
+259 

+	#_SC_RE_DUP_MAX
+ 16
+
+	)
+
+260 

+	#_SC_2_VERSION
+ 17
+
+	)
+
+261 

+	#_SC_2_C_BIND
+ 18
+
+	)
+
+262 

+	#_SC_2_C_DEV
+ 19
+
+	)
+
+263 

+	#_SC_2_CHAR_TERM
+ 20
+
+	)
+
+264 

+	#_SC_2_FORT_DEV
+ 21
+
+	)
+
+265 

+	#_SC_2_FORT_RUN
+ 22
+
+	)
+
+266 

+	#_SC_2_LOCALEDEF
+ 23
+
+	)
+
+267 

+	#_SC_2_SW_DEV
+ 24
+
+	)
+
+268 

+	#_SC_2_UPE
+ 25
+
+	)
+
+269 

+	#_SC_STREAM_MAX
+ 26
+
+	)
+
+270 

+	#_SC_TZNAME_MAX
+ 27
+
+	)
+
+271 

+	#_SC_ASYNCHRONOUS_IO
+ 28
+
+	)
+
+272 

+	#_SC_PAGESIZE
+ 29
+
+	)
+
+273 

+	#_SC_MEMLOCK
+ 30
+
+	)
+
+274 

+	#_SC_MEMLOCK_RANGE
+ 31
+
+	)
+
+275 

+	#_SC_MEMORY_PROTECTION
+ 32
+
+	)
+
+276 

+	#_SC_MESSAGE_PASSING
+ 33
+
+	)
+
+277 

+	#_SC_PRIORITIZED_IO
+ 34
+
+	)
+
+278 

+	#_SC_PRIORITY_SCHEDULING
+ 35
+
+	)
+
+279 

+	#_SC_REALTIME_SIGNALS
+ 36
+
+	)
+
+280 

+	#_SC_SEMAPHORES
+ 37
+
+	)
+
+281 

+	#_SC_FSYNC
+ 38
+
+	)
+
+282 

+	#_SC_SHARED_MEMORY_OBJECTS
+ 39
+
+	)
+
+283 

+	#_SC_SYNCHRONIZED_IO
+ 40
+
+	)
+
+284 

+	#_SC_TIMERS
+ 41
+
+	)
+
+285 

+	#_SC_AIO_LISTIO_MAX
+ 42
+
+	)
+
+286 

+	#_SC_AIO_MAX
+ 43
+
+	)
+
+287 

+	#_SC_AIO_PRIO_DELTA_MAX
+ 44
+
+	)
+
+288 

+	#_SC_DELAYTIMER_MAX
+ 45
+
+	)
+
+289 

+	#_SC_MQ_OPEN_MAX
+ 46
+
+	)
+
+290 

+	#_SC_MAPPED_FILES
+ 47
+
+	)
+
+291 

+	#_SC_RTSIG_MAX
+ 48
+
+	)
+
+292 

+	#_SC_SEM_NSEMS_MAX
+ 49
+
+	)
+
+293 

+	#_SC_SEM_VALUE_MAX
+ 50
+
+	)
+
+294 

+	#_SC_SIGQUEUE_MAX
+ 51
+
+	)
+
+295 

+	#_SC_TIMER_MAX
+ 52
+
+	)
+
+296 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+297 

+	#_SC_NPROCESSORS_CONF
+ 57
+
+	)
+
+298 

+	#_SC_NPROCESSORS_ONLN
+ 58
+
+	)
+
+300 

+	#_SC_2_PBS
+ 59
+
+	)
+
+301 

+	#_SC_2_PBS_ACCOUNTING
+ 60
+
+	)
+
+302 

+	#_SC_2_PBS_CHECKPOINT
+ 61
+
+	)
+
+303 

+	#_SC_2_PBS_LOCATE
+ 62
+
+	)
+
+304 

+	#_SC_2_PBS_MESSAGE
+ 63
+
+	)
+
+305 

+	#_SC_2_PBS_TRACK
+ 64
+
+	)
+
+306 

+	#_SC_ADVISORY_INFO
+ 65
+
+	)
+
+307 

+	#_SC_BARRIERS
+ 66
+
+	)
+
+308 

+	#_SC_CLOCK_SELECTION
+ 67
+
+	)
+
+309 

+	#_SC_CPUTIME
+ 68
+
+	)
+
+310 

+	#_SC_FILE_LOCKING
+ 69
+
+	)
+
+311 

+	#_SC_GETGR_R_SIZE_MAX
+ 70
+
+	)
+
+312 

+	#_SC_GETPW_R_SIZE_MAX
+ 71
+
+	)
+
+313 

+	#_SC_HOST_NAME_MAX
+ 72
+
+	)
+
+314 

+	#_SC_LOGIN_NAME_MAX
+ 73
+
+	)
+
+315 

+	#_SC_MONOTONIC_CLOCK
+ 74
+
+	)
+
+316 

+	#_SC_MQ_PRIO_MAX
+ 75
+
+	)
+
+317 

+	#_SC_READER_WRITER_LOCKS
+ 76
+
+	)
+
+318 

+	#_SC_REGEXP
+ 77
+
+	)
+
+319 

+	#_SC_SHELL
+ 78
+
+	)
+
+320 

+	#_SC_SPAWN
+ 79
+
+	)
+
+321 

+	#_SC_SPIN_LOCKS
+ 80
+
+	)
+
+322 

+	#_SC_SPORADIC_SERVER
+ 81
+
+	)
+
+323 

+	#_SC_THREAD_ATTR_STACKADDR
+ 82
+
+	)
+
+324 

+	#_SC_THREAD_ATTR_STACKSIZE
+ 83
+
+	)
+
+325 

+	#_SC_THREAD_CPUTIME
+ 84
+
+	)
+
+326 

+	#_SC_THREAD_DESTRUCTOR_ITERATIONS
+ 85
+
+	)
+
+327 

+	#_SC_THREAD_KEYS_MAX
+ 86
+
+	)
+
+328 

+	#_SC_THREAD_PRIO_INHERIT
+ 87
+
+	)
+
+329 

+	#_SC_THREAD_PRIO_PROTECT
+ 88
+
+	)
+
+330 

+	#_SC_THREAD_PRIORITY_SCHEDULING
+ 89
+
+	)
+
+331 

+	#_SC_THREAD_PROCESS_SHARED
+ 90
+
+	)
+
+332 

+	#_SC_THREAD_SAFE_FUNCTIONS
+ 91
+
+	)
+
+333 

+	#_SC_THREAD_SPORADIC_SERVER
+ 92
+
+	)
+
+334 

+	#_SC_THREAD_STACK_MIN
+ 93
+
+	)
+
+335 

+	#_SC_THREAD_THREADS_MAX
+ 94
+
+	)
+
+336 

+	#_SC_TIMEOUTS
+ 95
+
+	)
+
+337 

+	#_SC_THREADS
+ 96
+
+	)
+
+338 

+	#_SC_TRACE
+ 97
+
+	)
+
+339 

+	#_SC_TRACE_EVENT_FILTER
+ 98
+
+	)
+
+340 

+	#_SC_TRACE_INHERIT
+ 99
+
+	)
+
+341 

+	#_SC_TRACE_LOG
+ 100
+
+	)
+
+342 

+	#_SC_TTY_NAME_MAX
+ 101
+
+	)
+
+343 

+	#_SC_TYPED_MEMORY_OBJECTS
+ 102
+
+	)
+
+344 

+	#_SC_V6_ILP32_OFF32
+ 103
+
+	)
+
+345 

+	#_SC_V6_ILP32_OFFBIG
+ 104
+
+	)
+
+346 

+	#_SC_V6_LP64_OFF64
+ 105
+
+	)
+
+347 

+	#_SC_V6_LPBIG_OFFBIG
+ 106
+
+	)
+
+348 

+	#_SC_IPV6
+ 118
+
+	)
+
+349 

+	#_SC_RAW_SOCKETS
+ 119
+
+	)
+
+350 

+	#_SC_SYMLOOP_MAX
+ 120
+
+	)
+
+351 

+	#_SC_ATEXIT_MAX
+ 107
+
+	)
+
+352 

+	#_SC_IOV_MAX
+ 56
+
+	)
+
+353 

+	#_SC_PAGE_SIZE
+ 
+_SC_PAGESIZE
+
+
+	)
+
+354 

+	#_SC_XOPEN_CRYPT
+ 108
+
+	)
+
+355 

+	#_SC_XOPEN_ENH_I18N
+ 109
+
+	)
+
+356 

+	#_SC_XOPEN_LEGACY
+ 110
+
+	)
+
+357 

+	#_SC_XOPEN_REALTIME
+ 111
+
+	)
+
+358 

+	#_SC_XOPEN_REALTIME_THREADS
+ 112
+
+	)
+
+359 

+	#_SC_XOPEN_SHM
+ 113
+
+	)
+
+360 

+	#_SC_XOPEN_STREAMS
+ 114
+
+	)
+
+361 

+	#_SC_XOPEN_UNIX
+ 115
+
+	)
+
+362 

+	#_SC_XOPEN_VERSION
+ 116
+
+	)
+
+363 

+	#_SC_XOPEN_XCU_VERSION
+ 121
+
+	)
+
+364 

+	#_SC_XBS5_ILP32_OFF32
+ 122
+
+	)
+
+365 

+	#_SC_XBS5_ILP32_OFFBIG
+ 123
+
+	)
+
+366 

+	#_SC_XBS5_LP64_OFF64
+ 124
+
+	)
+
+367 

+	#_SC_XBS5_LPBIG_OFFBIG
+ 125
+
+	)
+
+368 

+	#_SC_SS_REPL_MAX
+ 126
+
+	)
+
+369 

+	#_SC_TRACE_EVENT_NAME_MAX
+ 127
+
+	)
+
+370 

+	#_SC_TRACE_NAME_MAX
+ 128
+
+	)
+
+371 

+	#_SC_TRACE_SYS_MAX
+ 129
+
+	)
+
+372 

+	#_SC_TRACE_USER_EVENT_MAX
+ 130
+
+	)
+
+373 

+	#_SC_PASS_MAX
+ 131
+
+	)
+
+375 #i�de�
+_CS_PATH
+
+
+376 

+	#_CS_PATH
+ 1
+
+	)
+
+378 

+	#_CS_POSIX_V6_ILP32_OFF32_CFLAGS
+ 2
+
+	)
+
+379 

+	#_CS_POSIX_V6_ILP32_OFF32_LDFLAGS
+ 3
+
+	)
+
+380 

+	#_CS_POSIX_V6_ILP32_OFF32_LIBS
+ 4
+
+	)
+
+381 

+	#_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS
+ 5
+
+	)
+
+382 

+	#_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS
+ 6
+
+	)
+
+383 

+	#_CS_POSIX_V6_ILP32_OFFBIG_LIBS
+ 7
+
+	)
+
+384 

+	#_CS_POSIX_V6_LP64_OFF64_CFLAGS
+ 8
+
+	)
+
+385 

+	#_CS_POSIX_V6_LP64_OFF64_LDFLAGS
+ 9
+
+	)
+
+386 

+	#_CS_POSIX_V6_LP64_OFF64_LIBS
+ 10
+
+	)
+
+387 

+	#_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS
+ 11
+
+	)
+
+388 

+	#_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS
+ 12
+
+	)
+
+389 

+	#_CS_POSIX_V6_LPBIG_OFFBIG_LIBS
+ 13
+
+	)
+
+390 

+	#_CS_POSIX_V6_WIDTH_RESTRICTED_ENVS
+ 14
+
+	)
+
+393 

+	#_CS_XBS5_ILP32_OFF32_CFLAGS
+ 20
+
+	)
+
+394 

+	#_CS_XBS5_ILP32_OFF32_LDFLAGS
+ 21
+
+	)
+
+395 

+	#_CS_XBS5_ILP32_OFF32_LIBS
+ 22
+
+	)
+
+396 

+	#_CS_XBS5_ILP32_OFF32_LINTFLAGS
+ 23
+
+	)
+
+397 

+	#_CS_XBS5_ILP32_OFFBIG_CFLAGS
+ 24
+
+	)
+
+398 

+	#_CS_XBS5_ILP32_OFFBIG_LDFLAGS
+ 25
+
+	)
+
+399 

+	#_CS_XBS5_ILP32_OFFBIG_LIBS
+ 26
+
+	)
+
+400 

+	#_CS_XBS5_ILP32_OFFBIG_LINTFLAGS
+ 27
+
+	)
+
+401 

+	#_CS_XBS5_LP64_OFF64_CFLAGS
+ 28
+
+	)
+
+402 

+	#_CS_XBS5_LP64_OFF64_LDFLAGS
+ 29
+
+	)
+
+403 

+	#_CS_XBS5_LP64_OFF64_LIBS
+ 30
+
+	)
+
+404 

+	#_CS_XBS5_LP64_OFF64_LINTFLAGS
+ 31
+
+	)
+
+405 

+	#_CS_XBS5_LPBIG_OFFBIG_CFLAGS
+ 32
+
+	)
+
+406 

+	#_CS_XBS5_LPBIG_OFFBIG_LDFLAGS
+ 33
+
+	)
+
+407 

+	#_CS_XBS5_LPBIG_OFFBIG_LIBS
+ 34
+
+	)
+
+408 

+	#_CS_XBS5_LPBIG_OFFBIG_LINTFLAGS
+ 35
+
+	)
+
+410 

+	#_CS_DARWIN_USER_DIR
+ 65536
+
+	)
+
+411 

+	#_CS_DARWIN_USER_TEMP_DIR
+ 65537
+
+	)
+
+412 

+	#_CS_DARWIN_USER_CACHE_DIR
+ 65538
+
+	)
+
+414 
+__BEGIN_DECLS
+
+
+416 
+	$_ex�
+(�
+__d�d2
+;
+
+417 
+	`ac�ss
+(const *, );
+
+419 
+	`��m
+();
+
+420 
+	`chd�
+(const *);
+
+421 
+	`chown
+(cڡ *, 
+uid_t
+, 
+gid_t
+);
+
+422 
+	$�o�
+(�
+	`__DARWIN_ALIAS_C
+(
+�o�
+);
+
+423 
+size_t
+ 
+	$c�f�r
+(, *, 
+size_t
+�
+	`__DARWIN_ALIAS
+(
+c�f�r
+);
+
+424 *
+	`�y�
+(const *, const *);
+
+425 *
+	`��mid
+(*);
+
+426 
+	`dup
+();
+
+427 
+	`dup2
+(, );
+
+428 #i�
+__DARWIN_UNIX03
+
+
+429 
+	$��y�
+(*, �
+	`__DARWIN_ALIAS
+(
+��y�
+);
+
+431 
+	`��y�
+(*, );
+
+433 
+	`exe�
+(const *, const *, ...);
+
+434 
+	`exe�e
+(const *, const *, ...);
+
+435 
+	`exe�p
+(const *, const *, ...);
+
+436 
+	`execv
+(const *, * const *);
+
+437 
+	`execve
+(const *, * const *, * const *);
+
+438 
+	`execvp
+(const *, * const *);
+
+439 
+	`fchown
+(, 
+uid_t
+, 
+gid_t
+);
+
+440 
+	`fchd�
+();
+
+441 
+pid_t
+ 
+	`f�k
+();
+
+442 
+	`�hc�f
+(, );
+
+443 
+	$fsync
+(�
+	`__DARWIN_ALIAS_C
+(
+fsync
+);
+
+444 
+	`�run��
+(, 
+off_t
+);
+
+445 *
+	`g�cwd
+(*, 
+size_t
+);
+
+446 
+gid_t
+ 
+	`g�egid
+();
+
+447 
+uid_t
+ 
+	`g�euid
+();
+
+448 
+gid_t
+ 
+	`g�gid
+();
+
+449 
+	`g�groups
+(, 
+gid_t
+ []);
+
+450 
+	`g�ho�id
+();
+
+451 
+	`g�ho��me
+(*, 
+size_t
+);
+
+452 *
+	`g�log�
+();
+
+453 
+	`g�log�_r
+(*, 
+size_t
+);
+
+454 
+	$g��t
+(, * cڡ [], cڡ *�
+	`__DARWIN_ALIAS
+(
+g��t
+);
+
+455 
+pid_t
+ 
+	`g�pgid
+(pid_t);
+
+456 
+pid_t
+ 
+	`g�pg�
+();
+
+457 
+pid_t
+ 
+	`g�pid
+();
+
+458 
+pid_t
+ 
+	`g��id
+();
+
+459 
+pid_t
+ 
+	`g�sid
+(pid_t);
+
+460 
+uid_t
+ 
+	`g�uid
+();
+
+461 *
+	`g�wd
+(*);
+
+462 
+	`i��y
+();
+
+463 
+	$lchown
+(cڡ *, 
+uid_t
+, 
+gid_t
+�
+	`__DARWIN_ALIAS
+(
+lchown
+);
+
+464 
+	`l�k
+(const *, const *);
+
+465 
+	$lockf
+(, , 
+off_t
+�
+	`__DARWIN_ALIAS_C
+(
+lockf
+);
+
+466 
+off_t
+ 
+	`l�ek
+(, off_t, );
+
+467 
+	$ni�
+(�
+	`__DARWIN_ALIAS
+(
+ni�
+);
+
+468 
+	`�thc�f
+(const *, );
+
+469 
+	$�u�
+(�
+	`__DARWIN_ALIAS_C
+(
+�u�
+);
+
+470 
+	`p�e
+([2]);
+
+471 
+ssize_t
+ 
+	$��d
+(, *, 
+size_t
+, 
+off_t
+�
+	`__DARWIN_ALIAS_C
+(
+��d
+);
+
+472 
+ssize_t
+ 
+	$pwr�e
+(, cڡ *, 
+size_t
+, 
+off_t
+�
+	`__DARWIN_ALIAS_C
+(
+pwr�e
+);
+
+473 
+ssize_t
+ 
+	$�ad
+(, *, 
+size_t
+�
+	`__DARWIN_ALIAS_C
+(
+�ad
+);
+
+474 
+ssize_t
+ 
+	`�adl�k
+(cڡ * 
+__��ri�
+, * __��ri�, 
+size_t
+);
+
+475 
+	`rmd�
+(const *);
+
+476 
+	`��gid
+(
+gid_t
+);
+
+477 
+	`��uid
+(
+uid_t
+);
+
+478 
+	`�tgid
+(
+gid_t
+);
+
+479 
+	`��gid
+(
+pid_t
+,�id_t);
+
+480 #i�
+__DARWIN_UNIX03
+
+
+481 
+pid_t
+ 
+	$��g�
+(�
+	`__DARWIN_ALIAS
+(
+��g�
+);
+
+483 
+	`��g�
+(
+pid_t
+ 
+pid
+,�id_�
+pg�
+);
+
+485 
+	$��egid
+(
+gid_t
+, gid_t�
+	`__DARWIN_ALIAS
+(
+��egid
+);
+
+486 
+	$��euid
+(
+uid_t
+, uid_t�
+	`__DARWIN_ALIAS
+(
+��euid
+);
+
+487 
+pid_t
+ 
+	`�tsid
+();
+
+488 
+	`�tuid
+(
+uid_t
+);
+
+490 
+	$��p
+(�
+	`__DARWIN_ALIAS_C
+(
+��p
+);
+
+491 
+	`swab
+(cڡ * 
+__��ri�
+, * __��ri�, 
+ssize_t
+);
+
+492 
+	`syml�k
+(const *, const *);
+
+493 
+	`sync
+();
+
+494 
+	`sysc�f
+();
+
+495 
+pid_t
+ 
+	`tcg�pg�
+();
+
+496 
+	`tc��g�
+(, 
+pid_t
+);
+
+497 
+	`�un��
+(cڡ *, 
+off_t
+);
+
+498 *
+	`�y�me
+();
+
+499 #i�
+__DARWIN_UNIX03
+
+
+500 
+	$�y�me_r
+(, *, 
+size_t
+�
+	`__DARWIN_ALIAS
+(
+�y�me_r
+);
+
+502 *
+	`�y�me_r
+(, *, 
+size_t
+);
+
+504 
+u�c�ds_t
+
+
+505 
+	`u��m
+(
+u�c�ds_t
+, useconds_t);
+
+506 
+	`uƚk
+(const *);
+
+507 
+	$u��p
+(
+u�c�ds_t
+�
+	`__DARWIN_ALIAS_C
+(
+u��p
+);
+
+508 
+pid_t
+ 
+	`vf�k
+();
+
+509 
+ssize_t
+ 
+	$wr�e
+(, cڡ *, 
+size_t
+�
+	`__DARWIN_ALIAS_C
+(
+wr�e
+);
+
+511 
*
+ݏrg
+;
+
+512 

+�t�d
+, 
+݋�
+, 
+�t�t
+;
+
+514 #if !
+	`def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+515 
+	~<sys/���.h
+>
+
+517 
+	$_Ex�
+(�
+__d�d2
+;
+
+518 
+	`ac�ssx_�
+(cڡ 
+ac�ssx_des��t�
+ *, 
+size_t
+, *, 
+uid_t
+);
+
+519 
+	`ac�
+(const *);
+
+520 
+	`add_�of�
+(*, 
+size_t
+, , );
+
+521 *
+	`brk
+(const *);
+
+522 
+	`chro�
+(const *);
+
+523 
+	`�du�rsh�l
+();
+
+524 
+	`execvP
+(const *, const *, * const *);
+
+525 *
+	`f�ag�o�r
+();
+
+526 
+	`g�d�b�size
+();
+
+527 
+	`g�doma��me
+(*, );
+
+528 
+	`g�grou�i�
+(const *, , *, *);
+
+529 
+mode_t
+ 
+	`g�mode
+(const *, mode_t);
+
+530 
+	$g��gesize
+(�
+__pu�2
+;
+
+531 *
+	`g��ss
+(const *);
+
+532 
+	`g���eid
+(, 
+uid_t
+ *, 
+gid_t
+ *);
+
+533 
+	`g�pgid
+(
+pid_t
+ 
+_pid
+);
+
+534 
+	`g�sgroups_�
+(*, 
+uuid_t
+);
+
+535 
+	`g�sid
+(
+pid_t
+ 
+_pid
+);
+
+536 *
+	`g�u�rsh�l
+();
+
+537 
+	`g�wgroups_�
+(*, 
+uuid_t
+);
+
+538 
+	`��groups
+(const *, );
+
+539 
+	`�u�rok
+(, , const *, const *);
+
+540 
+	`�u�rok_�
+(const *, , , const *, const *);
+
+541 
+	`is�tugid
+();
+
+542 *
+	`mkd�mp
+(*);
+
+543 
+	`mknod
+(cڡ *, 
+mode_t
+, 
+dev_t
+);
+
+544 
+	`mk�emp
+(*);
+
+545 
+	`mk�emps
+(*, );
+
+546 *
+	`mk�mp
+(*);
+
+547 
+	`nfssvc
+(, *);
+
+548 
+	`�of�
+(*, 
+size_t
+, , );
+
+549 
+	`�h�ad_�tugid_�
+(
+uid_t
+, 
+gid_t
+);
+
+550 
+	`�h�ad_g�ugid_�
+�
+uid_t
+ *, 
+gid_t
+ *);
+
+551 
+	`rcmd
+(**, , const *, const *, const *, *);
+
+552 
+	`rcmd_af
+(**, , const *, const *, const *, *,
+
+554 
+	`�bo�
+();
+
+555 
+	`�voke
+(const *);
+
+556 
+	`�esvp�t
+(*);
+
+557 
+	`�esvp�t_af
+(*, );
+
+558 
+	`ru�rok
+(const *, , const *, const *);
+
+559 *
+	`sbrk
+();
+
+560 
+	`�tdoma��me
+(const *, );
+
+561 
+	`�tgroups
+(, cڡ 
+gid_t
+ *);
+
+562 
+	`�tho�id
+();
+
+563 
+	`�tho��me
+(const *, );
+
+564 #i�
+__DARWIN_UNIX03
+
+
+565 
+	$�tkey
+(cڡ *�
+	`__DARWIN_ALIAS
+(
+�tkey
+);
+
+567 
+	`�tkey
+(const *);
+
+569 
+	`��og�
+(const *);
+
+570 *
+	`�tmode
+(const *);
+
+571 
+	`��gid
+(
+gid_t
+);
+
+572 
+	`��uid
+(
+uid_t
+);
+
+573 
+	`�tsgroups_�
+(, cڡ 
+uuid_t
+);
+
+574 
+	`�tu�rsh�l
+();
+
+575 
+	`�twgroups_�
+(, cڡ 
+uuid_t
+);
+
+576 
+	`��of�ags
+(**, *, *);
+
+577 
+	`sw��
+(const *);
+
+578 
+	`sys��
+(, ...);
+
+579 
+	`�y��
+();
+
+580 
+	`und��e
+(const *);
+
+581 
+	`unwh�eout
+(const *);
+
+582 *
+	`v�loc
+(
+size_t
+);
+
+584 
*
+subݏrg
+;
+
+585 
+	`g�sub�t
+(**, * const *, **);
+
+588 #ifde�
+__LP64__
+
+
+589 
+	$g���li�
+(cڡ *,*,*,
+size_t
+,�
+	`__DARWIN_ALIAS
+(
+g���li�
+);
+
+590 
+	$����i�
+(cڡ *,*,*,
+size_t
+,�
+	`__DARWIN_ALIAS
+(
+����i�
+);
+
+591 
+	`exch�ged�a
+(const *,const *,);
+
+592 
+	`g�d������r
+(,*,*,
+size_t
+,*,*,*,);
+
+593 
+	`��chfs
+(const *,*,*,,,*);
+
+595 
+	`fs�l
+(const *,,*,);
+
+597 
+	$g���li�
+(cڡ *,*,*,
+size_t
+,�
+	`__DARWIN_ALIAS
+(
+g���li�
+);
+
+598 
+	$����i�
+(cڡ *,*,*,
+size_t
+,�
+	`__DARWIN_ALIAS
+(
+����i�
+);
+
+599 
+	`exch�ged�a
+(const *,const *,);
+
+600 
+	`g�d������r
+(,*,*,
+size_t
+,*,*,*,);
+
+601 
+	`��chfs
+(const *,*,*,,,*);
+
+603 
+	`fs�l
+(const *,,*,);
+
+606 

+݌e�t
+;
+
+609 
+__END_DECLS
+
+
+	@/usr/include/_types.h
+
+24 #i�de�
+__TYPES_H_
+
+
+25 

+	#__TYPES_H_
+
+
+	)
+
+27 
+	~<sys/_ty�s.h
+>
+
+29 
+	t__d�w�_�_�em
+;
+
+30 
+	t__d�w�_w��ns_t
+;
+
+31 #ifde�
+__LP64__
+
+
+32 
+__u�t32_t
+ 
+	t__d�w�_w�y�_t
+;
+
+34 
+	t__d�w�_w�y�_t
+;
+
+37 #ifde�
+__WCHAR_MAX__
+
+
+38 

+	#__DARWIN_WCHAR_MAX
+ 
+__WCHAR_MAX__
+
+
+	)
+
+40 

+	#__DARWIN_WCHAR_MAX
+ 0x7fffffff
+
+	)
+
+43 #i�
+__DARWIN_WCHAR_MAX
+ > 0xffffU
+
+44 

+	#__DARWIN_WCHAR_MIN
+ (-0x7ffffff�- 1)
+
+	)
+
+46 

+	#__DARWIN_WCHAR_MIN
+ 0
+
+	)
+
+48 

+	#__DARWIN_WEOF
+ ((
+__d�w�_w�t_t
+)-1)
+
+	)
+
+	@/usr/include/_xlocale.h
+
+24 #i�de�
+__XLOCALE_H_
+
+
+25 

+	#__XLOCALE_H_
+
+
+	)
+
+27 
+	~<sys/cdefs.h
+>
+
+29 
+__BEGIN_DECLS
+
+
+30 
+___mb_cur_max
+();
+
+31 
+___mb_cur_max_l
+(
+lo��_t
+);
+
+32 
+	g__END_DECLS
+
+
+	@/usr/include/alloca.h
+
+24 #i�de�
+_ALLOCA_H_
+
+
+25 

+	#_ALLOCA_H_
+
+
+	)
+
+27 
+	~<sys/cdefs.h
+>
+
+28 
+	~<_ty�s.h
+>
+
+30 #i�def 
+_SIZE_T
+
+
+31 

+	#_SIZE_T
+
+
+	)
+
+32 
+__d�w�_size_t
+ 
+	tsize_t
+;
+
+35 
+__BEGIN_DECLS
+
+
+36 *
+�lo�
+(
+size_t
+);
+
+37 
+	g__END_DECLS
+
+
+39 #i�
+def�ed
+(
+__GNUC__
+) && __GNUC__ >= 3
+
+41 #unde�
+�lo�
+
+
+42 #unde�
+__�lo�
+
+
+43 

+	#�lo�
+(
+size
+�
+	`__�lo�
+(size)
+
+	)
+
+44 

+	#__�lo�
+(
+size
+�
+	`__bu�t�_�lo�
+(size)
+
+	)
+
+	@/usr/include/available.h
+
+65 #i�de�
+_AVAILABLE_H_
+
+
+66 

+	#_AVAILABLE_H_
+
+
+	)
+
+72 

+	#__MAC_OS_X_VERSION_10_0
+ 1000
+
+	)
+
+73 

+	#__MAC_OS_X_VERSION_10_1
+ 1010
+
+	)
+
+74 

+	#__MAC_OS_X_VERSION_10_2
+ 1020
+
+	)
+
+75 

+	#__MAC_OS_X_VERSION_10_3
+ 1030
+
+	)
+
+76 

+	#__MAC_OS_X_VERSION_10_4
+ 1040
+
+	)
+
+77 

+	#__MAC_OS_X_VERSION_10_5
+ 1050
+
+	)
+
+84 #i�de�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+
+
+85 #ifde�
+__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__
+
+
+86 

+	#__MAC_OS_X_VERSION_MIN_REQUIRED
+ 
+__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__
+
+
+	)
+
+88 #i�
+__�c64__
+ || 
+__i386__
+ || 
+__x86_64__
+
+
+89 

+	#__MAC_OS_X_VERSION_MIN_REQUIRED
+ 
+__MAC_OS_X_VERSION_10_4
+
+
+	)
+
+91 

+	#__MAC_OS_X_VERSION_MIN_REQUIRED
+ 
+__MAC_OS_X_VERSION_10_1
+
+
+	)
+
+99 #i�de�
+__MAC_OS_X_VERSION_MAX_ALLOWED
+
+
+100 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ > 
+__MAC_OS_X_VERSION_10_5
+
+
+101 

+	#__MAC_OS_X_VERSION_MAX_ALLOWED
+ 
+__MAC_OS_X_VERSION_MIN_REQUIRED
+
+
+	)
+
+103 

+	#__MAC_OS_X_VERSION_MAX_ALLOWED
+ 
+__MAC_OS_X_VERSION_10_5
+
+
+	)
+
+110 #i�
+__MAC_OS_X_VERSION_MAX_ALLOWED
+ < 
+__MAC_OS_X_VERSION_MIN_REQUIRED
+
+
+111 #�r� 
+__MAC_OS_X_VERSION_MAX_ALLOWED
+ 
+mu�
+ 
+be
+ >�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+
+
+113 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ < 
+__MAC_OS_X_VERSION_10_0
+
+
+114 #�r� 
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ 
+mu�
+ 
+be
+ >�
+__MAC_OS_X_VERSION_10_0
+
+
+120 #i�
+def�ed
+(
+__GNUC__
+�&& ((__GNUC__ >�4�|| ((__GNUC__ =�3�&& (
+__GNUC_MINOR__
+ >�1))�&& (
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >= 1020)
+
+121 

+	#__DARWIN_WEAK_IMPORT_ATTRIBUTE
+ 
+	`__��ibu�__
+((
+w�k_imp�t
+))
+
+	)
+
+122 #�i�
+def�ed
+(
+__MWERKS__
+�&& (__MWERKS__ >�0x3205�&& (
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >= 1020)
+
+123 

+	#__DARWIN_WEAK_IMPORT_ATTRIBUTE
+ 
+	`__��ibu�__
+((
+w�k_imp�t
+))
+
+	)
+
+125 

+	#__DARWIN_WEAK_IMPORT_ATTRIBUTE
+
+
+	)
+
+131 #i�
+def�ed
+(
+__GNUC__
+�&& ((__GNUC__ >�4�|| ((__GNUC__ =�3�&& (
+__GNUC_MINOR__
+ >= 1)))
+
+132 

+	#__DARWIN_DEPRECATED_ATTRIBUTE
+ 
+	`__��ibu�__
+((
+d����d
+))
+
+	)
+
+134 

+	#__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+140 #i�
+def�ed
+(
+__GNUC__
+�&& ((__GNUC__ >�4�|| ((__GNUC__ =�3�&& (
+__GNUC_MINOR__
+ >= 1)))
+
+141 

+	#__DARWIN_UNAVAILABLE_ATTRIBUTE
+ 
+	`__��ibu�__
+((
+u�va�ab�
+))
+
+	)
+
+143 

+	#__DARWIN_UNAVAILABLE_ATTRIBUTE
+
+
+	)
+
+153 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER
+
+
+	)
+
+161 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+168 

+	#__DEPRECATED_IN_MAC_OS_X_VERSION_10_0_AND_LATER
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+180 #i�
+__MAC_OS_X_VERSION_MAX_ALLOWED
+ < 
+__MAC_OS_X_VERSION_10_1
+
+
+181 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_1_AND_LATER
+ 
+__DARWIN_UNAVAILABLE_ATTRIBUTE
+
+
+	)
+
+182 #�i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ < 
+__MAC_OS_X_VERSION_10_1
+
+
+183 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_1_AND_LATER
+ 
+__DARWIN_WEAK_IMPORT_ATTRIBUTE
+
+
+	)
+
+185 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_1_AND_LATER
+
+
+	)
+
+194 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >�
+__MAC_OS_X_VERSION_10_1
+
+
+195 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_1_AND_LATER_BUT_DEPRECATED
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+197 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_1_AND_LATER_BUT_DEPRECATED
+ 
+__AVAILABLE_MAC_OS_X_VERSION_10_1_AND_LATER
+
+
+	)
+
+206 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >�
+__MAC_OS_X_VERSION_10_1
+
+
+207 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_1
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+209 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_1
+ 
+__AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER
+
+
+	)
+
+217 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >�
+__MAC_OS_X_VERSION_10_1
+
+
+218 

+	#__DEPRECATED_IN_MAC_OS_X_VERSION_10_1_AND_LATER
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+220 

+	#__DEPRECATED_IN_MAC_OS_X_VERSION_10_1_AND_LATER
+
+
+	)
+
+234 #i�
+__MAC_OS_X_VERSION_MAX_ALLOWED
+ < 
+__MAC_OS_X_VERSION_10_2
+
+
+235 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER
+ 
+__DARWIN_UNAVAILABLE_ATTRIBUTE
+
+
+	)
+
+236 #�i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ < 
+__MAC_OS_X_VERSION_10_2
+
+
+237 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER
+ 
+__DARWIN_WEAK_IMPORT_ATTRIBUTE
+
+
+	)
+
+239 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER
+
+
+	)
+
+248 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >�
+__MAC_OS_X_VERSION_10_2
+
+
+249 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER_BUT_DEPRECATED
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+251 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER_BUT_DEPRECATED
+ 
+__AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER
+
+
+	)
+
+260 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >�
+__MAC_OS_X_VERSION_10_2
+
+
+261 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_2
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+263 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_2
+ 
+__AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER
+
+
+	)
+
+272 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >�
+__MAC_OS_X_VERSION_10_2
+
+
+273 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_1_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_2
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+275 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_1_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_2
+ 
+__AVAILABLE_MAC_OS_X_VERSION_10_1_AND_LATER
+
+
+	)
+
+283 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >�
+__MAC_OS_X_VERSION_10_2
+
+
+284 

+	#__DEPRECATED_IN_MAC_OS_X_VERSION_10_2_AND_LATER
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+286 

+	#__DEPRECATED_IN_MAC_OS_X_VERSION_10_2_AND_LATER
+
+
+	)
+
+298 #i�
+__MAC_OS_X_VERSION_MAX_ALLOWED
+ < 
+__MAC_OS_X_VERSION_10_3
+
+
+299 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_3_AND_LATER
+ 
+__DARWIN_UNAVAILABLE_ATTRIBUTE
+
+
+	)
+
+300 #�i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ < 
+__MAC_OS_X_VERSION_10_3
+
+
+301 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_3_AND_LATER
+ 
+__DARWIN_WEAK_IMPORT_ATTRIBUTE
+
+
+	)
+
+303 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_3_AND_LATER
+
+
+	)
+
+312 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >�
+__MAC_OS_X_VERSION_10_3
+
+
+313 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_3_AND_LATER_BUT_DEPRECATED
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+315 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_3_AND_LATER_BUT_DEPRECATED
+ 
+__AVAILABLE_MAC_OS_X_VERSION_10_3_AND_LATER
+
+
+	)
+
+324 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >�
+__MAC_OS_X_VERSION_10_3
+
+
+325 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_3
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+327 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_3
+ 
+__AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER
+
+
+	)
+
+336 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >�
+__MAC_OS_X_VERSION_10_3
+
+
+337 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_1_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_3
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+339 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_1_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_3
+ 
+__AVAILABLE_MAC_OS_X_VERSION_10_1_AND_LATER
+
+
+	)
+
+348 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >�
+__MAC_OS_X_VERSION_10_3
+
+
+349 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_3
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+351 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_3
+ 
+__AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER
+
+
+	)
+
+359 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >�
+__MAC_OS_X_VERSION_10_3
+
+
+360 

+	#__DEPRECATED_IN_MAC_OS_X_VERSION_10_3_AND_LATER
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+362 

+	#__DEPRECATED_IN_MAC_OS_X_VERSION_10_3_AND_LATER
+
+
+	)
+
+375 #i�
+__MAC_OS_X_VERSION_MAX_ALLOWED
+ < 
+__MAC_OS_X_VERSION_10_4
+
+
+376 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER
+ 
+__DARWIN_UNAVAILABLE_ATTRIBUTE
+
+
+	)
+
+377 #�i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ < 
+__MAC_OS_X_VERSION_10_4
+
+
+378 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER
+ 
+__DARWIN_WEAK_IMPORT_ATTRIBUTE
+
+
+	)
+
+380 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER
+
+
+	)
+
+389 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >�
+__MAC_OS_X_VERSION_10_4
+
+
+390 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER_BUT_DEPRECATED
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+392 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER_BUT_DEPRECATED
+ 
+__AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER
+
+
+	)
+
+401 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >�
+__MAC_OS_X_VERSION_10_4
+
+
+402 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_4
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+404 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_4
+ 
+__AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER
+
+
+	)
+
+413 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >�
+__MAC_OS_X_VERSION_10_4
+
+
+414 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_1_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_4
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+416 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_1_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_4
+ 
+__AVAILABLE_MAC_OS_X_VERSION_10_1_AND_LATER
+
+
+	)
+
+425 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >�
+__MAC_OS_X_VERSION_10_4
+
+
+426 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_4
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+428 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_4
+ 
+__AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER
+
+
+	)
+
+437 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >�
+__MAC_OS_X_VERSION_10_4
+
+
+438 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_3_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_4
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+440 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_3_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_4
+ 
+__AVAILABLE_MAC_OS_X_VERSION_10_3_AND_LATER
+
+
+	)
+
+448 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >�
+__MAC_OS_X_VERSION_10_4
+
+
+449 

+	#__DEPRECATED_IN_MAC_OS_X_VERSION_10_4_AND_LATER
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+451 

+	#__DEPRECATED_IN_MAC_OS_X_VERSION_10_4_AND_LATER
+
+
+	)
+
+463 #i�
+__MAC_OS_X_VERSION_MAX_ALLOWED
+ < 
+__MAC_OS_X_VERSION_10_5
+
+
+464 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_5_AND_LATER
+ 
+__DARWIN_UNAVAILABLE_ATTRIBUTE
+
+
+	)
+
+465 #�i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ < 
+__MAC_OS_X_VERSION_10_5
+
+
+466 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_5_AND_LATER
+ 
+__DARWIN_WEAK_IMPORT_ATTRIBUTE
+
+
+	)
+
+468 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_5_AND_LATER
+
+
+	)
+
+477 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >�
+__MAC_OS_X_VERSION_10_5
+
+
+478 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_5_AND_LATER_BUT_DEPRECATED
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+480 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_5_AND_LATER_BUT_DEPRECATED
+ 
+__AVAILABLE_MAC_OS_X_VERSION_10_5_AND_LATER
+
+
+	)
+
+489 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >�
+__MAC_OS_X_VERSION_10_5
+
+
+490 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_5
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+492 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_5
+ 
+__AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER
+
+
+	)
+
+501 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >�
+__MAC_OS_X_VERSION_10_5
+
+
+502 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_1_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_5
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+504 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_1_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_5
+ 
+__AVAILABLE_MAC_OS_X_VERSION_10_1_AND_LATER
+
+
+	)
+
+513 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >�
+__MAC_OS_X_VERSION_10_5
+
+
+514 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_5
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+516 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_5
+ 
+__AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER
+
+
+	)
+
+525 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >�
+__MAC_OS_X_VERSION_10_5
+
+
+526 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_3_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_5
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+528 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_3_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_5
+ 
+__AVAILABLE_MAC_OS_X_VERSION_10_3_AND_LATER
+
+
+	)
+
+537 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >�
+__MAC_OS_X_VERSION_10_5
+
+
+538 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_5
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+540 

+	#__AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_5
+ 
+__AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER
+
+
+	)
+
+548 #i�
+__MAC_OS_X_VERSION_MIN_REQUIRED
+ >�
+__MAC_OS_X_VERSION_10_5
+
+
+549 

+	#__DEPRECATED_IN_MAC_OS_X_VERSION_10_5_AND_LATER
+ 
+__DARWIN_DEPRECATED_ATTRIBUTE
+
+
+	)
+
+551 

+	#__DEPRECATED_IN_MAC_OS_X_VERSION_10_5_AND_LATER
+
+
+	)
+
+	@/usr/include/machine/endian.h
+
+31 #i�de�
+_BSD_MACHINE_ENDIAN_H_
+
+
+32 

+	#_BSD_MACHINE_ENDIAN_H_
+
+
+	)
+
+34 #i�
+def�ed
+ (
+__�c__
+�|| def�ed(
+__�c64__
+)
+
+35 
+	~"�c/�d�n.h
+"
+
+36 #�i�
+def�ed
+ (
+__i386__
+�|| def�ed(
+__x86_64__
+)
+
+37 
+	~"i386/�d�n.h
+"
+
+38 #�i�
+def�ed
+ (
+__�m__
+)
+
+39 
+	~"�m/�d�n.h
+"
+
+41 #�r� 
+�ch�e�u�
+ 
+n�
+ 
+su�܋d
+
+
+	@/usr/include/machine/types.h
+
+31 #i�de�
+_BSD_MACHINE_TYPES_H_
+
+
+32 

+	#_BSD_MACHINE_TYPES_H_
+
+
+	)
+
+34 #i�
+def�ed
+ (
+__�c__
+�|| def�ed (
+__�c64__
+)
+
+35 
+	~"�c/ty�s.h
+"
+
+36 #�i�
+def�ed
+ (
+__i386__
+�|| def�ed(
+__x86_64__
+)
+
+37 
+	~"i386/ty�s.h
+"
+
+38 #�i�
+def�ed
+ (
+__�m__
+)
+
+39 
+	~"�m/ty�s.h
+"
+
+41 #�r� 
+�ch�e�u�
+ 
+n�
+ 
+su�܋d
+
+
+	@/usr/include/secure/_stdio.h
+
+24 #i�de�
+_STDIO_H_
+
+
+25 #�r� 
+�r�
+ "Never use <secure/_stdio.h> directly; include <stdio.h> instead."
+
+28 #i�de�
+_SECURE__STDIO_H_
+
+
+29 

+	#_SECURE__STDIO_H_
+
+
+	)
+
+31 
+	~<�cu�/_comm�.h
+>
+
+33 #i�
+_USE_FORTIFY_LEVEL
+ > 0
+
+35 #unde�
+�r�tf
+
+
+36 #unde�
+v�r�tf
+
+
+37 #unde�
+���tf
+
+
+38 #unde�
+v���tf
+
+
+42 

+	$__�r�tf_chk
+ (* 
+__��ri�
+, , 
+size_t
+,
+
+43 cڡ * 
+__��ri�
+, ...)
+
+44 
+	`__DARWIN_LDBL_COMPAT
+ (
+__�r�tf_chk
+);
+
+46 

+	#�r�tf
+(
+�r
+, ...) \
+
+47 
+	`__bu�t�___�r�tf_chk
+ (
+�r
+, 0, 
+	`__d�w�_obsz
+(�r), 
+__VA_ARGS__
+)
+
+	)
+
+49 

+	$__���tf_chk
+ (* 
+__��ri�
+, 
+size_t
+, , size_t,
+
+50 cڡ * 
+__��ri�
+, ...)
+
+51 
+	`__DARWIN_LDBL_COMPAT
+ (
+__���tf_chk
+);
+
+53 

+	#���tf
+(
+�r
+, 
+�n
+, ...) \
+
+54 
+	`__bu�t�___���tf_chk
+ (
+�r
+, 
+�n
+, 0, 
+	`__d�w�_obsz
+(�r), 
+__VA_ARGS__
+)
+
+	)
+
+56 

+	$__v�r�tf_chk
+ (* 
+__��ri�
+, , 
+size_t
+,
+
+57 cڡ * 
+__��ri�
+, 
+va_li�
+ 
+�g
+)
+
+58 
+	`__DARWIN_LDBL_COMPAT
+ (
+__v�r�tf_chk
+);
+
+60 

+	#v�r�tf
+(
+�r
+, 
+f�m�
+, 
+�
+) \
+
+61 
+	`__bu�t�___v�r�tf_chk
+ (
+�r
+, 0, 
+	`__d�w�_obsz
+(�r), 
+f�m�
+, 
+�
+)
+
+	)
+
+63 

+	$__v���tf_chk
+ (* 
+__��ri�
+, 
+size_t
+, , size_t,
+
+64 cڡ * 
+__��ri�
+, 
+va_li�
+ 
+�g
+)
+
+65 
+	`__DARWIN_LDBL_COMPAT
+ (
+__v���tf_chk
+);
+
+67 

+	#v���tf
+(
+�r
+, 
+�n
+, 
+f�m�
+, 
+�
+) \
+
+68 
+	`__bu�t�___v���tf_chk
+ (
+�r
+, 
+�n
+, 0, 
+	`__d�w�_obsz
+(�r), 
+f�m�
+, 
+�
+)
+
+	)
+
+	@/usr/include/sys/_select.h
+
+36 #i�de�
+_SYS__SELECT_H_
+
+
+37 

+	#_SYS__SELECT_H_
+
+
+	)
+
+39 
+	$���
+(, 
+fd_�t
+ * 
+__��ri�
+, fd_set * __restrict,
+
+40 
+fd_�t
+ * 
+__��ri�
+, 
+timev�
+ * __restrict)
+
+41 #i�
+	`def�ed
+(
+_DARWIN_C_SOURCE
+�|| def�ed(
+_DARWIN_UNLIMITED_SELECT
+)
+
+42 
+	$__DARWIN_EXTSN_C
+(
+���
+)
+
+44 #i�
+	`def�ed
+(
+__LP64__
+�&& !
+__DARWIN_NON_CANCELABLE
+
+
+45 
+	$__DARWIN_1050
+(
+���
+)
+
+47 
+	$__DARWIN_ALIAS_C
+(
+���
+)
+
+	@/usr/include/sys/_structs.h
+
+29 
+	~<sys/cdefs.h
+>
+
+30 
+	~<sys/_ty�s.h
+>
+
+32 #ifde�
+__�ed_ucڋxt_t
+
+
+33 #i�de�
+__�ed_�ru�_ucڋxt
+
+
+34 

+	#__�ed_�ru�_ucڋxt
+
+
+	)
+
+38 #ifde�
+__�ed_ucڋxt64_t
+
+
+39 #i�de�
+__�ed_�ru�_ucڋxt64
+
+
+40 

+	#__�ed_�ru�_ucڋxt64
+
+
+	)
+
+44 #ifde�
+__�ed_�ru�_ucڋxt
+
+
+45 #i�de�
+__�ed_�ru�_mcڋxt
+
+
+46 

+	#__�ed_�ru�_mcڋxt
+
+
+	)
+
+50 #ifde�
+__�ed_�ru�_ucڋxt64
+
+
+51 #i�de�
+__�ed_�ru�_mcڋxt64
+
+
+52 

+	#__�ed_�ru�_mcڋxt64
+
+
+	)
+
+56 #i�
+def�ed
+(
+__�ed_�ru�_mcڋxt
+�|| def�ed(
+__�ed_�ru�_mcڋxt64
+)
+
+57 
+	~<mach�e/_�ru�s.h
+>
+
+60 #i�
+def�ed
+(
+__�ed_�ack_t
+�|| def�ed(
+__�ed_�ru�_ucڋxt
+�|| def�ed(
+__�ed_�ru�_ucڋxt64
+)
+
+61 #i�de�
+__�ed_�ru�_sig�t�ack
+
+
+62 

+	#__�ed_�ru�_sig�t�ack
+
+
+	)
+
+66 #ifde�
+__�ed_�ru�_sig�t�ack
+
+
+67 #unde�
+__�ed_�ru�_sig�t�ack
+
+
+69 #i�de�
+_STRUCT_SIGALTSTACK
+
+
+70 #i�
+__DARWIN_UNIX03
+
+
+71 

+	#_STRUCT_SIGALTSTACK
+ 
+__d�w�_sig�t�ack
+
+
+	)
+
+73 

+	#_STRUCT_SIGALTSTACK
+ 
+sig�t�ack
+
+
+	)
+
+75 
+	g_STRUCT_SIGALTSTACK
+
+
+77 *
+	gss_�
+;
+
+78 
+__d�w�_size_t
+ 
+	gss_size
+;
+
+79 
+	gss_�ags
+;
+
+84 #ifde�
+__�ed_�ru�_time�ec
+
+
+85 #unde�
+__�ed_�ru�_time�ec
+
+
+86 #i�de�
+_STRUCT_TIMESPEC
+
+
+87 

+	#_STRUCT_TIMESPEC
+ 
+time�ec
+
+
+	)
+
+88 
+	g_STRUCT_TIMESPEC
+
+
+90 
+__d�w�_time_t
+ 
+	gtv_�c
+;
+
+91 
+	gtv_n�c
+;
+
+96 #ifde�
+__�ed_�ru�_timev�
+
+
+97 #unde�
+__�ed_�ru�_timev�
+
+
+98 #i�de�
+_STRUCT_TIMEVAL
+
+
+99 

+	#_STRUCT_TIMEVAL
+ 
+timev�
+
+
+	)
+
+100 
+	g_STRUCT_TIMEVAL
+
+
+102 
+__d�w�_time_t
+ 
+	gtv_�c
+;
+
+103 
+__d�w�_su�c�ds_t
+ 
+	gtv_u�c
+;
+
+108 #ifde�
+__�ed_�ru�_timev�32
+
+
+109 #unde�
+__�ed_�ru�_timev�32
+
+
+110 #i�de�
+_STRUCT_TIMEVAL32
+
+
+111 

+	#_STRUCT_TIMEVAL32
+ 
+timev�32
+
+
+	)
+
+112 
+	g_STRUCT_TIMEVAL32
+
+
+114 
+__�t32_t
+ 
+	gtv_�c
+;
+
+115 
+__�t32_t
+ 
+	gtv_u�c
+;
+
+120 #ifde�
+__�ed_�ru�_ucڋxt
+
+
+121 #unde�
+__�ed_�ru�_ucڋxt
+
+
+122 #i�de�
+_STRUCT_UCONTEXT
+
+
+123 #i�
+__DARWIN_UNIX03
+
+
+124 

+	#_STRUCT_UCONTEXT
+ 
+__d�w�_ucڋxt
+
+
+	)
+
+126 

+	#_STRUCT_UCONTEXT
+ 
+ucڋxt
+
+
+	)
+
+128 
+	g_STRUCT_UCONTEXT
+
+
+130 
+	guc_ڡack
+;
+
+131 
+__d�w�_sig�t_t
+ 
+	guc_sigmask
+;
+
+132 
+_STRUCT_SIGALTSTACK
+ 
+	guc_�ack
+;
+
+133 
+_STRUCT_UCONTEXT
+ *
+	guc_l�k
+;
+
+134 
+__d�w�_size_t
+ 
+	guc_mcsize
+;
+
+135 
+_STRUCT_MCONTEXT
+ *
+	guc_mcڋxt
+;
+
+136 #ifde�
+_XOPEN_SOURCE
+
+
+137 
+_STRUCT_MCONTEXT
+ 
+	g__mcڋxt_d�a
+;
+
+143 #ifde�
+__�ed_�ru�_ucڋxt64
+
+
+144 #unde�
+__�ed_�ru�_ucڋxt64
+
+
+145 #i�de�
+_STRUCT_UCONTEXT64
+
+
+146 #i�
+__DARWIN_UNIX03
+
+
+147 

+	#_STRUCT_UCONTEXT64
+ 
+__d�w�_ucڋxt64
+
+
+	)
+
+149 

+	#_STRUCT_UCONTEXT64
+ 
+ucڋxt64
+
+
+	)
+
+151 
+	g_STRUCT_UCONTEXT64
+
+
+153 
+	guc_ڡack
+;
+
+154 
+__d�w�_sig�t_t
+ 
+	guc_sigmask
+;
+
+155 
+_STRUCT_SIGALTSTACK
+ 
+	guc_�ack
+;
+
+156 
+_STRUCT_UCONTEXT64
+ *
+	guc_l�k
+;
+
+157 
+__d�w�_size_t
+ 
+	guc_mcsize
+;
+
+158 
+_STRUCT_MCONTEXT64
+ *
+	guc_mcڋxt64
+;
+
+164 #ifde�
+__�ed_fd_�t
+
+
+165 #unde�
+__�ed_fd_�t
+
+
+166 #i�de�
+_FD_SET
+
+
+167 

+	#_FD_SET
+
+
+	)
+
+174 #ifde�
+FD_SETSIZE
+
+
+175 

+	#__DARWIN_FD_SETSIZE
+ 
+FD_SETSIZE
+
+
+	)
+
+177 

+	#__DARWIN_FD_SETSIZE
+ 1024
+
+	)
+
+179 

+	#__DARWIN_NBBY
+ 8
+
+	)
+
+180 

+	#__DARWIN_NFDBITS
+ ((
+__�t32_t
+�* 
+__DARWIN_NBBY
+�
+
+	)
+
+181 

+	#__DARWIN_howm�y
+(
+x
+, 
+y
+�(((x�+ ((y�- 1)�/ (y)�
+
+	)
+
+183 
+__BEGIN_DECLS
+
+
+184 
+	sfd_�t
+ {
+
+185 
+__�t32_t
+ 
+	mfds_b�s
+[
+__DARWIN_howm�y
+(
+__DARWIN_FD_SETSIZE
+, 
+__DARWIN_NFDBITS
+)];
+
+186 } 
+	tfd_�t
+;
+
+187 
+__END_DECLS
+
+
+190 
+__�l�e
+ 
+
+191 
+	$__d�w�_fd_is�t
+(
+_n
+, 
+fd_�t
+ *
+_p
+)
+
+193  (
+_p
+->
+fds_b�s
+[
+_n
+/
+__DARWIN_NFDBITS
+] & (1<<(_n % __DARWIN_NFDBITS)));
+
+194 
+	}
+}
+
+196 

+	#__DARWIN_FD_SET
+(
+n
+, 
+p
+�d�{ 
+__fd
+ = (n); (�)->
+fds_b�s
+[__fd/
+__DARWIN_NFDBITS
+] |�(1<<(__fd % __DARWIN_NFDBITS))); } 0)
+
+	)
+
+197 

+	#__DARWIN_FD_CLR
+(
+n
+, 
+p
+�d�{ 
+__fd
+ = (n); (�)->
+fds_b�s
+[__fd/
+__DARWIN_NFDBITS
+] &�~(1<<(__fd % __DARWIN_NFDBITS))); } 0)
+
+	)
+
+198 

+	#__DARWIN_FD_ISSET
+(
+n
+, 
+p
+�
+	`__d�w�_fd_is�t
+(�), (p))
+
+	)
+
+200 #i�
+__GNUC__
+ > 3 || __GNUC__ =�3 && 
+__GNUC_MINOR__
+ >= 3
+
+205 

+	#__DARWIN_FD_ZERO
+(
+p
+�
+	`__bu�t�_bz�o
+�, (*�)))
+
+	)
+
+207 

+	#__DARWIN_FD_ZERO
+(
+p
+�
+	`bz�o
+�, (*�)))
+
+	)
+
+210 

+	#__DARWIN_FD_COPY
+(
+f
+, 
+t
+�
+	`bc�y
+(f,�, (*(f)))
+
+	)
+
+214 #ifde�
+__�ed_�ack_t
+
+
+215 #unde�
+__�ed_�ack_t
+
+
+216 #i�de�
+_STACK_T
+
+
+217 

+	#_STACK_T
+
+
+	)
+
+218 
+_STRUCT_SIGALTSTACK
+ 
+	t�ack_t
+;
+
+222 #ifde�
+__�ed_ucڋxt_t
+
+
+223 #unde�
+__�ed_ucڋxt_t
+
+
+225 #i�de�
+_UCONTEXT_T
+
+
+226 

+	#_UCONTEXT_T
+
+
+	)
+
+227 
+_STRUCT_UCONTEXT
+ 
+	tucڋxt_t
+;
+
+231 #ifde�
+__�ed_ucڋxt64_t
+
+
+232 #unde�
+__�ed_ucڋxt64_t
+
+
+233 #i�de�
+_UCONTEXT64_T
+
+
+234 

+	#_UCONTEXT64_T
+
+
+	)
+
+235 
+_STRUCT_UCONTEXT64
+ 
+	tucڋxt64_t
+;
+
+	@/usr/include/sys/_types.h
+
+29 #i�de�
+_SYS__TYPES_H_
+
+
+30 

+	#_SYS__TYPES_H_
+
+
+	)
+
+32 
+	~<sys/cdefs.h
+>
+
+33 
+	~<mach�e/_ty�s.h
+>
+
+36 #i�
+def�ed
+(
+__LP64__
+)
+
+37 

+	#__PTHREAD_SIZE__
+ 1168
+
+	)
+
+38 

+	#__PTHREAD_ATTR_SIZE__
+ 56
+
+	)
+
+39 

+	#__PTHREAD_MUTEXATTR_SIZE__
+ 8
+
+	)
+
+40 

+	#__PTHREAD_MUTEX_SIZE__
+ 56
+
+	)
+
+41 

+	#__PTHREAD_CONDATTR_SIZE__
+ 8
+
+	)
+
+42 

+	#__PTHREAD_COND_SIZE__
+ 40
+
+	)
+
+43 

+	#__PTHREAD_ONCE_SIZE__
+ 8
+
+	)
+
+44 

+	#__PTHREAD_RWLOCK_SIZE__
+ 192
+
+	)
+
+45 

+	#__PTHREAD_RWLOCKATTR_SIZE__
+ 16
+
+	)
+
+47 

+	#__PTHREAD_SIZE__
+ 596
+
+	)
+
+48 

+	#__PTHREAD_ATTR_SIZE__
+ 36
+
+	)
+
+49 

+	#__PTHREAD_MUTEXATTR_SIZE__
+ 8
+
+	)
+
+50 

+	#__PTHREAD_MUTEX_SIZE__
+ 40
+
+	)
+
+51 

+	#__PTHREAD_CONDATTR_SIZE__
+ 4
+
+	)
+
+52 

+	#__PTHREAD_COND_SIZE__
+ 24
+
+	)
+
+53 

+	#__PTHREAD_ONCE_SIZE__
+ 4
+
+	)
+
+54 

+	#__PTHREAD_RWLOCK_SIZE__
+ 124
+
+	)
+
+55 

+	#__PTHREAD_RWLOCKATTR_SIZE__
+ 12
+
+	)
+
+58 
+	s__d�w�_�h�ad_h�d�r_�c
+
+
+60 (*
+	m__rout�e
+)(*);
+
+61 *
+	m__�g
+;
+
+62 
+__d�w�_�h�ad_h�d�r_�c
+ *
+	m__�xt
+;
+
+64 
+	s_�aque_�h�ad_��_t
+ { 
+	m__sig
+; 
+	m__�aque
+[
+__PTHREAD_ATTR_SIZE__
+]; };
+
+65 
+	s_�aque_�h�ad_c�d_t
+ { 
+	m__sig
+; 
+	m__�aque
+[
+__PTHREAD_COND_SIZE__
+]; };
+
+66 
+	s_�aque_�h�ad_c�d��_t
+ { 
+	m__sig
+; 
+	m__�aque
+[
+__PTHREAD_CONDATTR_SIZE__
+]; };
+
+67 
+	s_�aque_�h�ad_mu�x_t
+ { 
+	m__sig
+; 
+	m__�aque
+[
+__PTHREAD_MUTEX_SIZE__
+]; };
+
+68 
+	s_�aque_�h�ad_mu�x��_t
+ { 
+	m__sig
+; 
+	m__�aque
+[
+__PTHREAD_MUTEXATTR_SIZE__
+]; };
+
+69 
+	s_�aque_�h�ad_��_t
+ { 
+	m__sig
+; 
+	m__�aque
+[
+__PTHREAD_ONCE_SIZE__
+]; };
+
+70 
+	s_�aque_�h�ad_rwlock_t
+ { 
+	m__sig
+; 
+	m__�aque
+[
+__PTHREAD_RWLOCK_SIZE__
+]; };
+
+71 
+	s_�aque_�h�ad_rwlock��_t
+ { 
+	m__sig
+; 
+	m__�aque
+[
+__PTHREAD_RWLOCKATTR_SIZE__
+]; };
+
+72 
+	s_�aque_�h�ad_t
+ { 
+	m__sig
+; 
+__d�w�_�h�ad_h�d�r_�c
+ *
+	m__��nup_�ack
+; 
+	m__�aque
+[
+__PTHREAD_SIZE__
+]; };
+
+80 #ifde�
+__�lu�lus
+
+
+81 #ifde�
+__GNUG__
+
+
+82 

+	#__DARWIN_NULL
+ 
+__nu�
+
+
+	)
+
+84 #ifde�
+__LP64__
+
+
+85 

+	#__DARWIN_NULL
+ (0L)
+
+	)
+
+87 

+	#__DARWIN_NULL
+ 0
+
+	)
+
+91 

+	#__DARWIN_NULL
+ ((*)0)
+
+	)
+
+94 
+__�t64_t
+ 
+	t__d�w�_blk�t_t
+;
+
+95 
+__�t32_t
+ 
+	t__d�w�_blksize_t
+;
+
+96 
+__�t32_t
+ 
+	t__d�w�_dev_t
+;
+
+97 
+	t__d�w�_fsblk�t_t
+;
+
+98 
+	t__d�w�_fsf��t_t
+;
+
+99 
+__u�t32_t
+ 
+	t__d�w�_gid_t
+;
+
+100 
+__u�t32_t
+ 
+	t__d�w�_id_t
+;
+
+101 
+__u�t64_t
+ 
+	t__d�w�_�o64_t
+;
+
+102 #i�
+__DARWIN_64_BIT_INO_T
+
+
+103 
+__d�w�_�o64_t
+ 
+	t__d�w�_�o_t
+;
+
+105 
+__u�t32_t
+ 
+	t__d�w�_�o_t
+;
+
+107 
+__d�w�_�tu�l_t
+ 
+	t__d�w�_mach_p�t_�me_t
+;
+
+108 
+__d�w�_mach_p�t_�me_t
+ 
+	t__d�w�_mach_p�t_t
+;
+
+109 
+__u�t16_t
+ 
+	t__d�w�_mode_t
+;
+
+110 
+__�t64_t
+ 
+	t__d�w�_off_t
+;
+
+111 
+__�t32_t
+ 
+	t__d�w�_pid_t
+;
+
+112 
+_�aque_�h�ad_��_t
+
+
+113 
+	t__d�w�_�h�ad_��_t
+;
+
+114 
+_�aque_�h�ad_c�d_t
+
+
+115 
+	t__d�w�_�h�ad_c�d_t
+;
+
+116 
+_�aque_�h�ad_c�d��_t
+
+
+117 
+	t__d�w�_�h�ad_c�d��_t
+;
+
+118 
+	t__d�w�_�h�ad_key_t
+;
+
+119 
+_�aque_�h�ad_mu�x_t
+
+
+120 
+	t__d�w�_�h�ad_mu�x_t
+;
+
+121 
+_�aque_�h�ad_mu�x��_t
+
+
+122 
+	t__d�w�_�h�ad_mu�x��_t
+;
+
+123 
+_�aque_�h�ad_��_t
+
+
+124 
+	t__d�w�_�h�ad_��_t
+;
+
+125 
+_�aque_�h�ad_rwlock_t
+
+
+126 
+	t__d�w�_�h�ad_rwlock_t
+;
+
+127 
+_�aque_�h�ad_rwlock��_t
+
+
+128 
+	t__d�w�_�h�ad_rwlock��_t
+;
+
+129 
+_�aque_�h�ad_t
+
+
+130 *
+	t__d�w�_�h�ad_t
+;
+
+131 
+__u�t32_t
+ 
+	t__d�w�_sig�t_t
+;
+
+132 
+__�t32_t
+ 
+	t__d�w�_su�c�ds_t
+;
+
+133 
+__u�t32_t
+ 
+	t__d�w�_uid_t
+;
+
+134 
+__u�t32_t
+ 
+	t__d�w�_u�c�ds_t
+;
+
+135 
+	t__d�w�_uuid_t
+[16];
+
+	@/usr/include/sys/appleapiopts.h
+
+29 #i�de�
+__SYS_APPLEAPIOPTS_H__
+
+
+30 

+	#__SYS_APPLEAPIOPTS_H__
+
+
+	)
+
+33 #i�de�
+__APPLE_API_STANDARD
+
+
+34 

+	#__APPLE_API_STANDARD
+
+
+	)
+
+37 #i�de�
+__APPLE_API_STABLE
+
+
+38 

+	#__APPLE_API_STABLE
+
+
+	)
+
+41 #i�de�
+__APPLE_API_STRICT_CONFORMANCE
+
+
+43 #i�de�
+__APPLE_API_EVOLVING
+
+
+44 

+	#__APPLE_API_EVOLVING
+
+
+	)
+
+47 #i�de�
+__APPLE_API_UNSTABLE
+
+
+48 

+	#__APPLE_API_UNSTABLE
+
+
+	)
+
+51 #i�de�
+__APPLE_API_PRIVATE
+
+
+52 

+	#__APPLE_API_PRIVATE
+
+
+	)
+
+55 #i�de�
+__APPLE_API_OBSOLETE
+
+
+56 

+	#__APPLE_API_OBSOLETE
+
+
+	)
+
+	@/usr/include/sys/cdefs.h
+
+67 #i�def 
+_CDEFS_H_
+
+
+68 

+	#_CDEFS_H_
+
+
+	)
+
+70 #i�
+def�ed
+(
+__�lu�lus
+)
+
+71 

+	#__BEGIN_DECLS
+ 
"C" {
+
+	)
+
+72 

+	#__END_DECLS
+ }
+
+	)
+
+74 

+	#__BEGIN_DECLS
+
+
+	)
+
+75 

+	#__END_DECLS
+
+
+	)
+
+85 #i�
+def�ed
+(
+__STDC__
+�|| def�ed(
+__�lu�lus
+)
+
+86 

+	#__P
+(
+��os
+��o�
+
+	)
+
+87 

+	#__CONCAT
+(
+x
+,
+y
+�x ## 
+	)
+y
+
+88 

+	#__STRING
+(
+x
+�#x
+
+	)
+
+90 

+	#__cڡ
+ cڡ
+
+	)
+
+91 

+	#__sig�d
+ sig�d
+
+	)
+
+92 

+	#__vީ�e
+ vީ�e
+
+	)
+
+93 #i�
+def�ed
+(
+__�lu�lus
+)
+
+94 

+	#__�l�e
+ 
+�l�e
+
+
+	)
+
+96 #i�de�
+__GNUC__
+
+
+97 

+	#__�l�e
+
+
+	)
+
+102 

+	#__P
+(
+��os
+�(�
+
+	)
+
+103 

+	#__CONCAT
+(
+x
+,
+y
+�x 
+	)
+y
+
+104 

+	#__STRING
+(
+x
+�"x"
+
+	)
+
+106 #i�de�
+__GNUC__
+
+
+107 

+	#__cڡ
+
+
+	)
+
+108 

+	#__�l�e
+
+
+	)
+
+109 

+	#__sig�d
+
+
+	)
+
+110 

+	#__vީ�e
+
+
+	)
+
+121 #i�def 
+NO_ANSI_KEYWORDS
+
+
+122 
cڡ 
+__cڡ
+
+
+	)
+
+123 

+	#�l�e
+ 
+__�l�e
+
+
+	)
+
+124 
sig�d 
+__sig�d
+
+
+	)
+
+125 
vީ��
+__vީ�e
+
+
+	)
+
+137 #i�
+def�ed
+(
+__MWERKS__
+) && (__MWERKS__ > 0x2400)
+
+139 #�i�
+__GNUC__
+ > 2 || __GNUC__ =�2 && 
+__GNUC_MINOR__
+ >= 5
+
+140 

+	#__d�d2
+ 
+	`__��ibu�__
+((
+__nܑu�__
+))
+
+	)
+
+141 

+	#__pu�2
+ 
+	`__��ibu�__
+((
+__cڡ__
+))
+
+	)
+
+142 #i�
+__GNUC__
+ =�2 && 
+__GNUC_MINOR__
+ >= 5 && __GNUC_MINOR__ < 7
+
+143 

+	#__unu�d
+
+
+	)
+
+145 

+	#__unu�d
+ 
+	`__��ibu�__
+((
+__unu�d__
+))
+
+	)
+
+148 

+	#__��ibu�__
+(
+x
+�
+
+	)
+
+149 #i�
+def�ed
+(
+__GNUC__
+�&& !def�ed(
+__STRICT_ANSI__
+)
+
+151 

+	#__d�d
+ 
+__vީ�e
+
+
+	)
+
+152 

+	#__pu�
+ 
+__cڡ
+
+
+	)
+
+157 #i�de�
+__d�d
+
+
+158 

+	#__d�d
+
+
+	)
+
+159 

+	#__pu�
+
+
+	)
+
+161 #i�de�
+__d�d2
+
+
+162 

+	#__d�d2
+
+
+	)
+
+163 

+	#__pu�2
+
+
+	)
+
+164 

+	#__unu�d
+
+
+	)
+
+173 #i�!(
+__GNUC__
+ =�2 && 
+__GNUC_MINOR__
+ == 95)
+
+174 #i�
+__STDC_VERSION__
+ < 199901
+
+175 

+	#__��ri�
+
+
+	)
+
+177 

+	#__��ri�
+ 
+��ri�
+
+
+	)
+
+189 #i�
+__GNUC__
+ > 2 || __GNUC__ =�2 && 
+__GNUC_MINOR__
+ >= 7
+
+190 

+	#__��t�ike
+(
+fm�rg
+, 
+f��v��g
+) \
+
+191 
+	`__��ibu�__
+((
+	`__f�m�__
+ (
+__��tf__
+, 
+fm�rg
+, 
+f��v��g
+)))
+
+	)
+
+192 

+	#__s�n�ike
+(
+fm�rg
+, 
+f��v��g
+) \
+
+193 
+	`__��ibu�__
+((
+	`__f�m�__
+ (
+__s�nf__
+, 
+fm�rg
+, 
+f��v��g
+)))
+
+	)
+
+195 

+	#__��t�ike
+(
+fm�rg
+, 
+f��v��g
+)
+
+	)
+
+196 

+	#__s�n�ike
+(
+fm�rg
+, 
+f��v��g
+)
+
+	)
+
+199 

+	#__IDSTRING
+(
+�me
+,
+�r�g
+�cڡ �me[] 
+__unu�d
+ = 
+	)
+string
+
+201 #i�de�
+__COPYRIGHT
+
+
+202 

+	#__COPYRIGHT
+(
+s
+�
+	`__IDSTRING
+(
+c�yright
+,s)
+
+	)
+
+205 #i�de�
+__RCSID
+
+
+206 

+	#__RCSID
+(
+s
+�
+	`__IDSTRING
+(
+rcsid
+,s)
+
+	)
+
+209 #i�de�
+__SCCSID
+
+
+210 

+	#__SCCSID
+(
+s
+�
+	`__IDSTRING
+(
+sccsid
+,s)
+
+	)
+
+213 #i�de�
+__PROJECT_VERSION
+
+
+214 

+	#__PROJECT_VERSION
+(
+s
+�
+	`__IDSTRING
+(
+�oje�_v�si�
+,s)
+
+	)
+
+272 #i�!
+def�ed
+(
+__DARWIN_UNIX03
+)
+
+273 #i�
+def�ed
+(
+_DARWIN_C_SOURCE
+�|| def�ed(
+_XOPEN_SOURCE
+�|| def�ed(
+_POSIX_C_SOURCE
+�|| def�ed(
+__LP64__
+�|| (def�ed(
+__�m__
+�&& !def�ed(
+KERNEL
+))
+
+274 #i�
+def�ed
+(
+_NONSTD_SOURCE
+)
+
+277 

+	#__DARWIN_UNIX03
+ 1
+
+	)
+
+278 #�i�
+def�ed
+(
+_NONSTD_SOURCE
+�|| def�ed(
+KERNEL
+)
+
+279 

+	#__DARWIN_UNIX03
+ 0
+
+	)
+
+281 #i�
+def�ed
+(
+__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__
+) && ((__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__-0) < 1050)
+
+282 

+	#__DARWIN_UNIX03
+ 0
+
+	)
+
+284 

+	#__DARWIN_UNIX03
+ 1
+
+	)
+
+289 #i�!
+def�ed
+(
+__DARWIN_64_BIT_INO_T
+)
+
+290 #i�
+def�ed
+(
+_DARWIN_USE_64_BIT_INODE
+)
+
+291 

+	#__DARWIN_64_BIT_INO_T
+ 1
+
+	)
+
+292 #�i�
+def�ed
+(
+_DARWIN_NO_64_BIT_INODE
+�|| def�ed(
+KERNEL
+)
+
+293 

+	#__DARWIN_64_BIT_INO_T
+ 0
+
+	)
+
+295 

+	#__DARWIN_64_BIT_INO_T
+ 0
+
+	)
+
+299 #i�!
+def�ed
+(
+__DARWIN_NON_CANCELABLE
+)
+
+300 

+	#__DARWIN_NON_CANCELABLE
+ 0
+
+	)
+
+303 #i�!
+def�ed
+(
+__DARWIN_VERS_1050
+)
+
+304 #i�!
+def�ed
+(
+KERNEL
+�&& def�ed(
+__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__
+) && ((__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__-0) >= 1050)
+
+305 

+	#__DARWIN_VERS_1050
+ 1
+
+	)
+
+307 

+	#__DARWIN_VERS_1050
+ 0
+
+	)
+
+314 #i�
+__DARWIN_UNIX03
+
+
+315 #i�!
+def�ed
+(
+__LP64__
+�&& !def�ed(
+__�m__
+)
+
+316 

+	#__DARWIN_SUF_UNIX03
+ "$UNIX2003"
+
+	)
+
+317 

+	#__DARWIN_SUF_UNIX03_SET
+ 1
+
+	)
+
+319 

+	#__DARWIN_SUF_UNIX03
+
+
+	)
+
+320 

+	#__DARWIN_SUF_UNIX03_SET
+ 0
+
+	)
+
+323 #i�
+__DARWIN_64_BIT_INO_T
+
+
+324 

+	#__DARWIN_SUF_64_BIT_INO_T
+ "$INODE64"
+
+	)
+
+326 

+	#__DARWIN_SUF_64_BIT_INO_T
+
+
+	)
+
+329 #i�
+__DARWIN_NON_CANCELABLE
+
+
+330 

+	#__DARWIN_SUF_NON_CANCELABLE
+ "$NOCANCEL"
+
+	)
+
+332 

+	#__DARWIN_SUF_NON_CANCELABLE
+
+
+	)
+
+335 #i�
+__DARWIN_VERS_1050
+
+
+336 

+	#__DARWIN_SUF_1050
+ "$1050"
+
+	)
+
+338 

+	#__DARWIN_SUF_1050
+
+
+	)
+
+342 

+	#__DARWIN_SUF_UNIX03
+
+
+	)
+
+343 

+	#__DARWIN_SUF_UNIX03_SET
+ 0
+
+	)
+
+344 

+	#__DARWIN_SUF_64_BIT_INO_T
+
+
+	)
+
+345 

+	#__DARWIN_SUF_NON_CANCELABLE
+
+
+	)
+
+346 

+	#__DARWIN_SUF_1050
+
+
+	)
+
+349 

+	#__DARWIN_SUF_EXTSN
+ "$DARWIN_EXTSN"
+
+	)
+
+354 

+	#__DARWIN_ALIAS
+(
+sym
+�
+	`__asm
+("_" 
+	`__STRING
+(sym�
+__DARWIN_SUF_UNIX03
+)
+
+	)
+
+355 

+	#__DARWIN_ALIAS_C
+(
+sym
+�
+	`__asm
+("_" 
+	`__STRING
+(sym�
+__DARWIN_SUF_NON_CANCELABLE
+ 
+__DARWIN_SUF_UNIX03
+)
+
+	)
+
+356 

+	#__DARWIN_ALIAS_I
+(
+sym
+�
+	`__asm
+("_" 
+	`__STRING
+(sym�
+__DARWIN_SUF_64_BIT_INO_T
+ 
+__DARWIN_SUF_UNIX03
+)
+
+	)
+
+357 

+	#__DARWIN_INODE64
+(
+sym
+�
+	`__asm
+("_" 
+	`__STRING
+(sym�
+__DARWIN_SUF_64_BIT_INO_T
+)
+
+	)
+
+359 

+	#__DARWIN_1050
+(
+sym
+�
+	`__asm
+("_" 
+	`__STRING
+(sym�
+__DARWIN_SUF_1050
+)
+
+	)
+
+360 

+	#__DARWIN_1050ALIAS
+(
+sym
+�
+	`__asm
+("_" 
+	`__STRING
+(sym�
+__DARWIN_SUF_1050
+ 
+__DARWIN_SUF_UNIX03
+)
+
+	)
+
+361 

+	#__DARWIN_1050ALIAS_C
+(
+sym
+�
+	`__asm
+("_" 
+	`__STRING
+(sym�
+__DARWIN_SUF_1050
+ 
+__DARWIN_SUF_NON_CANCELABLE
+ 
+__DARWIN_SUF_UNIX03
+)
+
+	)
+
+362 

+	#__DARWIN_1050ALIAS_I
+(
+sym
+�
+	`__asm
+("_" 
+	`__STRING
+(sym�
+__DARWIN_SUF_1050
+ 
+__DARWIN_SUF_64_BIT_INO_T
+ 
+__DARWIN_SUF_UNIX03
+)
+
+	)
+
+363 

+	#__DARWIN_1050INODE64
+(
+sym
+�
+	`__asm
+("_" 
+	`__STRING
+(sym�
+__DARWIN_SUF_1050
+ 
+__DARWIN_SUF_64_BIT_INO_T
+)
+
+	)
+
+365 

+	#__DARWIN_EXTSN
+(
+sym
+�
+	`__asm
+("_" 
+	`__STRING
+(sym�
+__DARWIN_SUF_EXTSN
+)
+
+	)
+
+366 

+	#__DARWIN_EXTSN_C
+(
+sym
+�
+	`__asm
+("_" 
+	`__STRING
+(sym�
+__DARWIN_SUF_EXTSN
+ 
+__DARWIN_SUF_NON_CANCELABLE
+)
+
+	)
+
+389 #i�
+def�ed
+(
+_POSIX_C_SOURCE
+) && _POSIX_C_SOURCE == 1L
+
+390 #unde�
+_POSIX_C_SOURCE
+
+
+391 

+	#_POSIX_C_SOURCE
+ 199009L
+
+	)
+
+395 #i�
+def�ed
+(
+_POSIX_C_SOURCE
+) && _POSIX_C_SOURCE == 2L
+
+396 #unde�
+_POSIX_C_SOURCE
+
+
+397 

+	#_POSIX_C_SOURCE
+ 199209L
+
+	)
+
+401 #ifde�
+_XOPEN_SOURCE
+
+
+402 #i�
+_XOPEN_SOURCE
+ - 0L >= 600L
+
+403 #unde�
+_POSIX_C_SOURCE
+
+
+404 

+	#_POSIX_C_SOURCE
+ 200112L
+
+	)
+
+405 #�i�
+_XOPEN_SOURCE
+ - 0L >= 500L
+
+406 #unde�
+_POSIX_C_SOURCE
+
+
+407 

+	#_POSIX_C_SOURCE
+ 199506L
+
+	)
+
+415 #i�
+def�ed
+(
+_POSIX_SOURCE
+�&& !def�ed(
+_POSIX_C_SOURCE
+)
+
+416 

+	#_POSIX_C_SOURCE
+ 198808L
+
+	)
+
+424 

+	#__DARWIN_NO_LONG_LONG
+ (
+	`def�ed
+(
+__STRICT_ANSI__
+) \
+
+425 && (
+__STDC_VERSION__
+-0 < 199901L) \
+
+426 && !
+	`def�ed
+(
+__GNUG__
+))
+
+	)
+
+434 #i�
+def�ed
+(
+__�c__
+)
+
+435 #i�
+def�ed
+(
+__LDBL_MANT_DIG__
+�&& def�ed(
+__DBL_MANT_DIG__
+) && \
+
+436 
+__LDBL_MANT_DIG__
+ > 
+__DBL_MANT_DIG__
+
+
+437 #i�
+__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__
+-0 < 1040
+
+438 

+	#__DARWIN_LDBL_COMPAT
+(
+x
+�
+	`__asm
+("_" 
+	`__STRING
+(x�"$LDBLStub")
+
+	)
+
+440 

+	#__DARWIN_LDBL_COMPAT
+(
+x
+�
+	`__asm
+("_" 
+	`__STRING
+(x�"$LDBL128")
+
+	)
+
+442 

+	#__DARWIN_LDBL_COMPAT2
+(
+x
+�
+	`__asm
+("_" 
+	`__STRING
+(x�"$LDBL128")
+
+	)
+
+443 

+	#__DARWIN_LONG_DOUBLE_IS_DOUBLE
+ 0
+
+	)
+
+445 

+	#__DARWIN_LDBL_COMPAT
+(
+x
+�
+
+	)
+
+446 

+	#__DARWIN_LDBL_COMPAT2
+(
+x
+�
+
+	)
+
+447 

+	#__DARWIN_LONG_DOUBLE_IS_DOUBLE
+ 1
+
+	)
+
+449 #�i�
+def�ed
+(
+__i386__
+�|| def�ed(
+__�c64__
+�|| def�ed(
+__x86_64__
+�|| def�ed (
+__�m__
+)
+
+450 

+	#__DARWIN_LDBL_COMPAT
+(
+x
+�
+
+	)
+
+451 

+	#__DARWIN_LDBL_COMPAT2
+(
+x
+�
+
+	)
+
+452 

+	#__DARWIN_LONG_DOUBLE_IS_DOUBLE
+ 0
+
+	)
+
+454 #�r� 
+Unknown
+ 
+�ch�e�u�
+
+
+460 #i�
+__GNUC__
+ >= 3
+
+461 

+	#__d����d
+ 
+	`__��ibu�__
+((
+d����d
+))
+
+	)
+
+463 

+	#__d����d
+
+
+	)
+
+474 #i�
+__DARWIN_LONG_DOUBLE_IS_DOUBLE
+
+
+475 

+	#_DARWIN_FEATURE_LONG_DOUBLE_IS_DOUBLE
+ 1
+
+	)
+
+482 #i�
+__DARWIN_UNIX03
+
+
+483 

+	#_DARWIN_FEATURE_UNIX_CONFORMANCE
+ 3
+
+	)
+
+490 #i�
+__DARWIN_64_BIT_INO_T
+
+
+491 

+	#_DARWIN_FEATURE_64_BIT_INODE
+ 1
+
+	)
+
+	@/usr/include/sys/dirent.h
+
+75 #i�de�
+_SYS_DIRENT_H
+
+
+76 

+	#_SYS_DIRENT_H
+
+
+	)
+
+78 
+	~<sys/_ty�s.h
+>
+
+79 
+	~<sys/cdefs.h
+>
+
+81 #i�def 
+_INO_T
+
+
+82 
+__d�w�_�o_t
+ 
+	t�o_t
+;
+
+83 

+	#_INO_T
+
+
+	)
+
+87 

+	#__DARWIN_MAXNAMLEN
+ 255
+
+	)
+
+89 #�agm�
+�ck
+(4)
+
+91 #i�!
+__DARWIN_64_BIT_INO_T
+
+
+92 
+	sd��t
+ {
+
+93 
+�o_t
+ 
+	md_�o
+;
+
+94 
+__u�t16_t
+ 
+	md_���
+;
+
+95 
+__u�t8_t
+ 
+	md_ty�
+;
+
+96 
+__u�t8_t
+ 
+	md_�m�n
+;
+
+97 
+	md_�me
+[
+__DARWIN_MAXNAMLEN
+ + 1];
+
+101 #�agm�
+�ck
+()
+
+103 

+	#__DARWIN_MAXPATHLEN
+ 1024
+
+	)
+
+105 

+	#__DARWIN_STRUCT_DIRENTRY
+ { \
+
+106 
+__u�t64_t
+ 
+d_�o
+; \
+
+107 
+__u�t64_t
+ 
+d_�ekoff
+; \
+
+108 
+__u�t16_t
+ 
+d_���
+; \
+
+109 
+__u�t16_t
+ 
+d_�m�n
+; \
+
+110 
+__u�t8_t
+ 
+d_ty�
+; \
+
+111 
+d_�me
+[
+__DARWIN_MAXPATHLEN
+]; \
+
+112 }
+
+	)
+
+114 #i�
+__DARWIN_64_BIT_INO_T
+
+
+115 
+d��t
+ 
+	g__DARWIN_STRUCT_DIRENTRY
+;
+
+120 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+121 

+	#d_f��o
+ 
+d_�o
+
+
+	)
+
+122 

+	#MAXNAMLEN
+ 
+__DARWIN_MAXNAMLEN
+
+
+	)
+
+126 

+	#DT_UNKNOWN
+ 0
+
+	)
+
+127 

+	#DT_FIFO
+ 1
+
+	)
+
+128 

+	#DT_CHR
+ 2
+
+	)
+
+129 

+	#DT_DIR
+ 4
+
+	)
+
+130 

+	#DT_BLK
+ 6
+
+	)
+
+131 

+	#DT_REG
+ 8
+
+	)
+
+132 

+	#DT_LNK
+ 10
+
+	)
+
+133 

+	#DT_SOCK
+ 12
+
+	)
+
+134 

+	#DT_WHT
+ 14
+
+	)
+
+139 

+	#IFTODT
+(
+mode
+�(((mode�& 0170000�>> 12)
+
+	)
+
+140 

+	#DTTOIF
+(
+d�ty�
+�((d�ty��<< 12)
+
+	)
+
+	@/usr/include/sys/fcntl.h
+
+70 #i�de�
+_SYS_FCNTL_H_
+
+
+71 

+	#_SYS_FCNTL_H_
+
+
+	)
+
+78 
+	~<sys/_ty�s.h
+>
+
+79 
+	~<sys/cdefs.h
+>
+
+82 #i�de�
+_SIZE_T
+
+
+83 

+	#_SIZE_T
+
+
+	)
+
+84 
+__d�w�_size_t
+ 
+	tsize_t
+;
+
+87 #i�def 
+_MODE_T
+
+
+88 
+__d�w�_mode_t
+ 
+	tmode_t
+;
+
+89 

+	#_MODE_T
+
+
+	)
+
+92 #i�de�
+_OFF_T
+
+
+93 
+__d�w�_off_t
+ 
+	toff_t
+;
+
+94 

+	#_OFF_T
+
+
+	)
+
+97 #i�de�
+_PID_T
+
+
+98 
+__d�w�_pid_t
+ 
+	tpid_t
+;
+
+99 

+	#_PID_T
+
+
+	)
+
+110 

+	#O_RDONLY
+ 0x0000
+
+	)
+
+111 

+	#O_WRONLY
+ 0x0001
+
+	)
+
+112 

+	#O_RDWR
+ 0x0002
+
+	)
+
+113 

+	#O_ACCMODE
+ 0x0003
+
+	)
+
+123 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+124 

+	#FREAD
+ 0x0001
+
+	)
+
+125 

+	#FWRITE
+ 0x0002
+
+	)
+
+127 

+	#O_NONBLOCK
+ 0x0004
+
+	)
+
+128 

+	#O_APPEND
+ 0x0008
+
+	)
+
+129 

+	#O_SYNC
+ 0x0080
+
+	)
+
+130 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+131 

+	#O_SHLOCK
+ 0x0010
+
+	)
+
+132 

+	#O_EXLOCK
+ 0x0020
+
+	)
+
+133 

+	#O_ASYNC
+ 0x0040
+
+	)
+
+134 

+	#O_FSYNC
+ 
+O_SYNC
+
+
+	)
+
+135 

+	#O_NOFOLLOW
+ 0x0100
+
+	)
+
+137 

+	#O_CREAT
+ 0x0200
+
+	)
+
+138 

+	#O_TRUNC
+ 0x0400
+
+	)
+
+139 

+	#O_EXCL
+ 0x0800
+
+	)
+
+140 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+141 

+	#O_EVTONLY
+ 0x8000
+
+	)
+
+145 

+	#O_NOCTTY
+ 0x20000
+
+	)
+
+148 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+149 

+	#O_DIRECTORY
+ 0x100000
+
+	)
+
+150 

+	#O_SYMLINK
+ 0x200000
+
+	)
+
+161 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+162 

+	#FAPPEND
+ 
+O_APPEND
+
+
+	)
+
+163 

+	#FASYNC
+ 
+O_ASYNC
+
+
+	)
+
+164 

+	#FFSYNC
+ 
+O_FSYNC
+
+
+	)
+
+165 

+	#FNONBLOCK
+ 
+O_NONBLOCK
+
+
+	)
+
+166 

+	#FNDELAY
+ 
+O_NONBLOCK
+
+
+	)
+
+167 

+	#O_NDELAY
+ 
+O_NONBLOCK
+
+
+	)
+
+174 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+175 

+	#CPF_OVERWRITE
+ 1
+
+	)
+
+176 

+	#CPF_IGNORE_MODE
+ 2
+
+	)
+
+177 

+	#CPF_MASK
+ (
+CPF_OVERWRITE
+|
+CPF_IGNORE_MODE
+)
+
+	)
+
+185 

+	#F_DUPFD
+ 0
+
+	)
+
+186 

+	#F_GETFD
+ 1
+
+	)
+
+187 

+	#F_SETFD
+ 2
+
+	)
+
+188 

+	#F_GETFL
+ 3
+
+	)
+
+189 

+	#F_SETFL
+ 4
+
+	)
+
+190 

+	#F_GETOWN
+ 5
+
+	)
+
+191 

+	#F_SETOWN
+ 6
+
+	)
+
+192 

+	#F_GETLK
+ 7
+
+	)
+
+193 

+	#F_SETLK
+ 8
+
+	)
+
+194 

+	#F_SETLKW
+ 9
+
+	)
+
+195 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+196 

+	#F_CHKCLEAN
+ 41
+
+	)
+
+197 

+	#F_PREALLOCATE
+ 42
+
+	)
+
+198 

+	#F_SETSIZE
+ 43
+
+	)
+
+199 

+	#F_RDADVISE
+ 44
+
+	)
+
+200 

+	#F_RDAHEAD
+ 45
+
+	)
+
+201 

+	#F_READBOOTSTRAP
+ 46
+
+	)
+
+202 

+	#F_WRITEBOOTSTRAP
+ 47
+
+	)
+
+203 

+	#F_NOCACHE
+ 48
+
+	)
+
+204 

+	#F_LOG2PHYS
+ 49
+
+	)
+
+205 

+	#F_GETPATH
+ 50
+
+	)
+
+206 

+	#F_FULLFSYNC
+ 51
+
+	)
+
+207 

+	#F_PATHPKG_CHECK
+ 52
+
+	)
+
+208 

+	#F_FREEZE_FS
+ 53
+
+	)
+
+209 

+	#F_THAW_FS
+ 54
+
+	)
+
+210 

+	#F_GLOBAL_NOCACHE
+ 55
+
+	)
+
+213 

+	#F_ADDSIGS
+ 59
+
+	)
+
+215 

+	#F_MARKDEPENDENCY
+ 60
+
+	)
+
+218 

+	#FCNTL_FS_SPECIFIC_BASE
+ 0x00010000
+
+	)
+
+223 

+	#FD_CLOEXEC
+ 1
+
+	)
+
+226 

+	#F_RDLCK
+ 1
+
+	)
+
+227 

+	#F_UNLCK
+ 2
+
+	)
+
+228 

+	#F_WRLCK
+ 3
+
+	)
+
+234 #i�de�
+SEEK_SET
+
+
+235 

+	#SEEK_SET
+ 0
+
+	)
+
+236 

+	#SEEK_CUR
+ 1
+
+	)
+
+237 

+	#SEEK_END
+ 2
+
+	)
+
+244 #i�de�
+S_IFMT
+
+
+246 

+	#S_IFMT
+ 0170000
+
+	)
+
+247 

+	#S_IFIFO
+ 0010000
+
+	)
+
+248 

+	#S_IFCHR
+ 0020000
+
+	)
+
+249 

+	#S_IFDIR
+ 0040000
+
+	)
+
+250 

+	#S_IFBLK
+ 0060000
+
+	)
+
+251 

+	#S_IFREG
+ 0100000
+
+	)
+
+252 

+	#S_IFLNK
+ 0120000
+
+	)
+
+253 

+	#S_IFSOCK
+ 0140000
+
+	)
+
+254 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+255 

+	#S_IFWHT
+ 0160000
+
+	)
+
+256 

+	#S_IFXATTR
+ 0200000
+
+	)
+
+261 

+	#S_IRWXU
+ 0000700
+
+	)
+
+262 

+	#S_IRUSR
+ 0000400
+
+	)
+
+263 

+	#S_IWUSR
+ 0000200
+
+	)
+
+264 

+	#S_IXUSR
+ 0000100
+
+	)
+
+266 

+	#S_IRWXG
+ 0000070
+
+	)
+
+267 

+	#S_IRGRP
+ 0000040
+
+	)
+
+268 

+	#S_IWGRP
+ 0000020
+
+	)
+
+269 

+	#S_IXGRP
+ 0000010
+
+	)
+
+271 

+	#S_IRWXO
+ 0000007
+
+	)
+
+272 

+	#S_IROTH
+ 0000004
+
+	)
+
+273 

+	#S_IWOTH
+ 0000002
+
+	)
+
+274 

+	#S_IXOTH
+ 0000001
+
+	)
+
+276 

+	#S_ISUID
+ 0004000
+
+	)
+
+277 

+	#S_ISGID
+ 0002000
+
+	)
+
+278 

+	#S_ISVTX
+ 0001000
+
+	)
+
+280 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+281 

+	#S_ISTXT
+ 
+S_ISVTX
+
+
+	)
+
+282 

+	#S_IREAD
+ 
+S_IRUSR
+
+
+	)
+
+283 

+	#S_IWRITE
+ 
+S_IWUSR
+
+
+	)
+
+284 

+	#S_IEXEC
+ 
+S_IXUSR
+
+
+	)
+
+288 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+291 

+	#F_ALLOCATECONTIG
+ 0x00000002
+
+	)
+
+292 

+	#F_ALLOCATEALL
+ 0x00000004
+
+	)
+
+296 

+	#F_PEOFPOSMODE
+ 3
+
+	)
+
+298 

+	#F_VOLPOSMODE
+ 4
+
+	)
+
+305 
+	s�ock
+ {
+
+306 
+off_t
+ 
+	ml_��t
+;
+
+307 
+off_t
+ 
+	ml_�n
+;
+
+308 
+pid_t
+ 
+	ml_pid
+;
+
+309 
+	ml_ty�
+;
+
+310 
+	ml_wh��
+;
+
+314 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+319 
+	s�dvis�y
+ {
+
+320 
+off_t
+ 
+	m�_off�t
+;
+
+321 
+	m�_cou�
+;
+
+329 
+	sfsig�tu�s
+ {
+
+330 
+off_t
+ 
+	mfs_f�e_��t
+;
+
+331 *
+	mfs_blob_��t
+;
+
+332 
+size_t
+ 
+	mfs_blob_size
+;
+
+333 } 
+	tfsig�tu�s_t
+;
+
+336 

+	#LOCK_SH
+ 0x01
+
+	)
+
+337 

+	#LOCK_EX
+ 0x02
+
+	)
+
+338 

+	#LOCK_NB
+ 0x04
+
+	)
+
+339 

+	#LOCK_UN
+ 0x08
+
+	)
+
+343 
+	sf��e
+ {
+
+344 
+	mf�_�ags
+;
+
+345 
+	mf�_posmode
+;
+
+346 
+off_t
+ 
+	mf�_off�t
+;
+
+347 
+off_t
+ 
+	mf�_�ngth
+;
+
+348 
+off_t
+ 
+	mf�_by���oc
+;
+
+349 } 
+	tf��e_t
+;
+
+353 
+	sfbo١���ns�r
+ {
+
+354 
+off_t
+ 
+	mfbt_off�t
+;
+
+355 
+size_t
+ 
+	mfbt_�ngth
+;
+
+356 *
+	mfbt_buf�r
+;
+
+357 } 
+	tfbo١���ns�r_t
+;
+
+377 #�agm�
+�ck
+(4)
+
+379 
+	slog2phys
+ {
+
+380 
+	ml2p_�ags
+;
+
+381 
+off_t
+ 
+	ml2p_c�tigby�s
+;
+
+382 
+off_t
+ 
+	ml2p_devoff�t
+;
+
+385 #�agm�
+�ck
+()
+
+387 

+	#O_POPUP
+ 0x80000000
+
+	)
+
+388 

+	#O_ALERT
+ 0x20000000
+
+	)
+
+394 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+395 #i�de�
+_FILESEC_T
+
+
+396 
+	g_f�e�c
+;
+
+397 
+_f�e�c
+ *
+	tf�e�c_t
+;
+
+398 

+	#_FILESEC_T
+
+
+	)
+
+401 
+	mFILESEC_OWNER
+ = 1,
+
+402 
+	mFILESEC_GROUP
+ = 2,
+
+403 
+	mFILESEC_UUID
+ = 3,
+
+404 
+	mFILESEC_MODE
+ = 4,
+
+405 
+	mFILESEC_ACL
+ = 5,
+
+406 
+	mFILESEC_GRPUUID
+ = 6,
+
+409 
+	mFILESEC_ACL_RAW
+ = 100,
+
+410 
+	mFILESEC_ACL_ALLOCSIZE
+ = 101
+
+411 } 
+	tf�e�c_�ݔty_t
+;
+
+414 

+	#FILESEC_GUID
+ 
+FILESEC_UUID
+
+
+	)
+
+417 
+__BEGIN_DECLS
+
+
+418 
+	$ݒ
+(cڡ *, , ...�
+	`__DARWIN_ALIAS_C
+(
+ݒ
+);
+
+419 
+	$��t
+(cڡ *, 
+mode_t
+�
+	`__DARWIN_ALIAS_C
+(
+��t
+);
+
+420 
+	$f��
+(, , ...�
+	`__DARWIN_ALIAS_C
+(
+f��
+);
+
+421 #i�!
+	`def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+422 
+	`ݒx_�
+(cڡ *, , 
+f�e�c_t
+);
+
+423 
+	`�ock
+(, );
+
+424 
+f�e�c_t
+ 
+	`f�e�c_��
+();
+
+425 
+f�e�c_t
+ 
+	`f�e�c_dup
+(filesec_t);
+
+426 
+	`f�e�c_�
+(
+f�e�c_t
+);
+
+427 
+	`f�e�c_g�_�ݔty
+(
+f�e�c_t
+, 
+f�e�c_�ݔty_t
+, *);
+
+428 
+	`f�e�c_�t_�ݔty
+(
+f�e�c_t
+, 
+f�e�c_�ݔty_t
+, const *);
+
+429 
+	`f�e�c_qu�y_�ݔty
+(
+f�e�c_t
+, 
+f�e�c_�ݔty_t
+, *);
+
+430 

+	#_FILESEC_UNSET_PROPERTY
+ ((*)0)
+
+	)
+
+431 

+	#_FILESEC_REMOVE_ACL
+ ((*)1)
+
+	)
+
+433 
+__END_DECLS
+
+
+	@/usr/include/sys/select.h
+
+63 #i�de�
+_SYS_SELECT_H_
+
+
+64 

+	#_SYS_SELECT_H_
+
+
+	)
+
+66 
+	~<sys/���pi�ts.h
+>
+
+67 
+	~<sys/cdefs.h
+>
+
+68 
+	~<sys/_ty�s.h
+>
+
+75 

+	#__�ed_fd_�t
+
+
+	)
+
+76 

+	#__�ed_�ru�_time�ec
+
+
+	)
+
+77 

+	#__�ed_�ru�_timev�
+
+
+	)
+
+78 
+	~<sys/_�ru�s.h
+>
+
+85 #i�def 
+_TIME_T
+
+
+86 

+	#_TIME_T
+
+
+	)
+
+87 
+__d�w�_time_t
+ 
+	ttime_t
+;
+
+90 #i�de�
+_SUSECONDS_T
+
+
+91 

+	#_SUSECONDS_T
+
+
+	)
+
+92 
+__d�w�_su�c�ds_t
+ 
+	tsu�c�ds_t
+;
+
+95 #i�de�
+_SIGSET_T
+
+
+96 

+	#_SIGSET_T
+
+
+	)
+
+97 
+__d�w�_sig�t_t
+ 
+	tsig�t_t
+;
+
+112 #i�def 
+FD_SETSIZE
+
+
+113 

+	#FD_SETSIZE
+ 
+__DARWIN_FD_SETSIZE
+
+
+	)
+
+115 #i�de�
+FD_SET
+
+
+116 

+	#FD_SET
+(
+n
+, 
+p
+�
+	`__DARWIN_FD_SET
+�,�)
+
+	)
+
+118 #i�de�
+FD_CLR
+
+
+119 

+	#FD_CLR
+(
+n
+, 
+p
+�
+	`__DARWIN_FD_CLR
+�,�)
+
+	)
+
+121 #i�de�
+FD_ISSET
+
+
+122 

+	#FD_ISSET
+(
+n
+, 
+p
+�
+	`__DARWIN_FD_ISSET
+�,�)
+
+	)
+
+124 #i�de�
+FD_ZERO
+
+
+125 

+	#FD_ZERO
+(
+p
+�
+	`__DARWIN_FD_ZERO
+�)
+
+	)
+
+127 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+128 #i�de�
+FD_COPY
+
+
+129 

+	#FD_COPY
+(
+f
+, 
+t
+�
+	`__DARWIN_FD_COPY
+(f,�)
+
+	)
+
+134 
+	g__BEGIN_DECLS
+
+
+136 #i�de� 
+__MWERKS__
+
+
+137 
+	$p���
+(, 
+fd_�t
+ * 
+__��ri�
+, fd_set * __restrict,
+
+138 
+fd_�t
+ * 
+__��ri�
+, cڡ 
+time�ec
+ * __restrict,
+
+139 cڡ 
+sig�t_t
+ * 
+__��ri�
+)
+
+140 #i�
+	`def�ed
+(
+_DARWIN_C_SOURCE
+�|| def�ed(
+_DARWIN_UNLIMITED_SELECT
+)
+
+141 
+	$__DARWIN_EXTSN_C
+(
+p���
+)
+
+143 #i�
+	`def�ed
+(
+__LP64__
+�&& !
+__DARWIN_NON_CANCELABLE
+
+
+144 
+	$__DARWIN_1050
+(
+p���
+)
+
+146 
+	$__DARWIN_ALIAS_C
+(
+p���
+)
+
+152 
+	~<sys/_���.h
+>
+
+154 
+__END_DECLS
+
+
+	@/usr/include/sys/unistd.h
+
+64 #i�de�
+_SYS_UNISTD_H_
+
+
+65 

+	#_SYS_UNISTD_H_
+
+
+	)
+
+67 
+	~<sys/cdefs.h
+>
+
+75 #ifdef 
+_NOT_AVAILABLE
+
+
+76 

+	#_POSIX_SAVED_IDS
+
+
+	)
+
+79 

+	#_POSIX_VERSION
+ 200112L
+
+	)
+
+80 

+	#_POSIX2_VERSION
+ 200112L
+
+	)
+
+84 #i�de�
+_POSIX_VDISABLE
+
+
+85 

+	#_POSIX_VDISABLE
+ (()'\377')
+
+	)
+
+88 

+	#_POSIX_THREAD_KEYS_MAX
+ 128
+
+	)
+
+91 

+	#F_OK
+ 0
+
+	)
+
+92 

+	#X_OK
+ (1<<0�
+
+	)
+
+93 

+	#W_OK
+ (1<<1�
+
+	)
+
+94 

+	#R_OK
+ (1<<2�
+
+	)
+
+96 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+102 

+	#_READ_OK
+ (1<<9�
+
+	)
+
+103 

+	#_WRITE_OK
+ (1<<10�
+
+	)
+
+104 

+	#_EXECUTE_OK
+ (1<<11�
+
+	)
+
+105 

+	#_DELETE_OK
+ (1<<12�
+
+	)
+
+106 

+	#_APPEND_OK
+ (1<<13�
+
+	)
+
+107 

+	#_RMFILE_OK
+ (1<<14�
+
+	)
+
+108 

+	#_RATTR_OK
+ (1<<15�
+
+	)
+
+109 

+	#_WATTR_OK
+ (1<<16�
+
+	)
+
+110 

+	#_REXT_OK
+ (1<<17�
+
+	)
+
+111 

+	#_WEXT_OK
+ (1<<18�
+
+	)
+
+112 

+	#_RPERM_OK
+ (1<<19�
+
+	)
+
+113 

+	#_WPERM_OK
+ (1<<20�
+
+	)
+
+114 

+	#_CHOWN_OK
+ (1<<21�
+
+	)
+
+116 

+	#_ACCESS_EXTENDED_MASK
+ (
+_READ_OK
+ | 
+_WRITE_OK
+ | 
+_EXECUTE_OK
+ | \
+
+117 
+_DELETE_OK
+ | 
+_APPEND_OK
+ | \
+
+118 
+_RMFILE_OK
+ | 
+_REXT_OK
+ | \
+
+119 
+_WEXT_OK
+ | 
+_RATTR_OK
+ | 
+_WATTR_OK
+ | 
+_RPERM_OK
+ | \
+
+120 
+_WPERM_OK
+ | 
+_CHOWN_OK
+)
+
+	)
+
+124 #i�de�
+SEEK_SET
+
+
+125 

+	#SEEK_SET
+ 0
+
+	)
+
+126 

+	#SEEK_CUR
+ 1
+
+	)
+
+127 

+	#SEEK_END
+ 2
+
+	)
+
+130 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+132 

+	#L_SET
+ 
+SEEK_SET
+
+
+	)
+
+133 

+	#L_INCR
+ 
+SEEK_CUR
+
+
+	)
+
+134 

+	#L_XTND
+ 
+SEEK_END
+
+
+	)
+
+137 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+138 
+	sac�ssx_des��t�
+ {
+
+139 
+	mad_�me_off�t
+;
+
+140 
+	mad_�ags
+;
+
+141 
+	mad_�d
+[2];
+
+143 

+	#ACCESSX_MAX_DESCRIPTORS
+ 100
+
+	)
+
+144 

+	#ACCESSX_MAX_TABLESIZE
+ (16 * 1024)
+
+	)
+
+148 

+	#_PC_LINK_MAX
+ 1
+
+	)
+
+149 

+	#_PC_MAX_CANON
+ 2
+
+	)
+
+150 

+	#_PC_MAX_INPUT
+ 3
+
+	)
+
+151 

+	#_PC_NAME_MAX
+ 4
+
+	)
+
+152 

+	#_PC_PATH_MAX
+ 5
+
+	)
+
+153 

+	#_PC_PIPE_BUF
+ 6
+
+	)
+
+154 

+	#_PC_CHOWN_RESTRICTED
+ 7
+
+	)
+
+155 

+	#_PC_NO_TRUNC
+ 8
+
+	)
+
+156 

+	#_PC_VDISABLE
+ 9
+
+	)
+
+158 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+159 

+	#_PC_NAME_CHARS_MAX
+ 10
+
+	)
+
+160 

+	#_PC_CASE_SENSITIVE
+ 11
+
+	)
+
+161 

+	#_PC_CASE_PRESERVING
+ 12
+
+	)
+
+162 

+	#_PC_EXTENDED_SECURITY_NP
+ 13
+
+	)
+
+163 

+	#_PC_AUTH_OPAQUE_NP
+ 14
+
+	)
+
+166 

+	#_PC_2_SYMLINKS
+ 15
+
+	)
+
+167 

+	#_PC_ALLOC_SIZE_MIN
+ 16
+
+	)
+
+168 

+	#_PC_ASYNC_IO
+ 17
+
+	)
+
+169 

+	#_PC_FILESIZEBITS
+ 18
+
+	)
+
+170 

+	#_PC_PRIO_IO
+ 19
+
+	)
+
+171 

+	#_PC_REC_INCR_XFER_SIZE
+ 20
+
+	)
+
+172 

+	#_PC_REC_MAX_XFER_SIZE
+ 21
+
+	)
+
+173 

+	#_PC_REC_MIN_XFER_SIZE
+ 22
+
+	)
+
+174 

+	#_PC_REC_XFER_ALIGN
+ 23
+
+	)
+
+175 

+	#_PC_SYMLINK_MAX
+ 24
+
+	)
+
+176 

+	#_PC_SYNC_IO
+ 25
+
+	)
+
+179 

+	#_CS_PATH
+ 1
+
+	)
+
+	@/usr/include/sys/wait.h
+
+64 #i�de�
+_SYS_WAIT_H_
+
+
+65 

+	#_SYS_WAIT_H_
+
+
+	)
+
+67 
+	~<sys/cdefs.h
+>
+
+68 
+	~<sys/_ty�s.h
+>
+
+80 
+	mP_ALL
+,
+
+81 
+	mP_PID
+,
+
+82 
+	mP_PGID
+
+
+83 } 
+	tidty�_t
+;
+
+89 #i�de�
+_PID_T
+
+
+90 
+__d�w�_pid_t
+ 
+	tpid_t
+;
+
+91 

+	#_PID_T
+
+
+	)
+
+94 #i�de�
+_ID_T
+
+
+95 
+__d�w�_id_t
+ 
+	tid_t
+;
+
+96 

+	#_ID_T
+
+
+	)
+
+116 
+	~<sys/sig�l.h
+>
+
+117 
+	~<sys/�sour�.h
+>
+
+128 

+	#WNOHANG
+ 0x00000001
+
+	)
+
+129 

+	#WUNTRACED
+ 0x00000002
+
+	)
+
+135 #i�
+def�ed
+(
+_POSIX_C_SOURCE
+�&& !def�ed(
+_DARWIN_C_SOURCE
+)
+
+136 

+	#_W_INT
+(
+i
+�(i)
+
+	)
+
+138 

+	#_W_INT
+(
+w
+�(*(*)&(w)�
+
+	)
+
+139 

+	#WCOREFLAG
+ 0200
+
+	)
+
+143 

+	#_WSTATUS
+(
+x
+�(
+	`_W_INT
+(x�& 0177)
+
+	)
+
+144 

+	#_WSTOPPED
+ 0177
+
+	)
+
+150 #i�
+__DARWIN_UNIX03
+
+
+151 

+	#WEXITSTATUS
+(
+x
+�((
+	`_W_INT
+(x�>> 8�& 0x000000ff)
+
+	)
+
+153 

+	#WEXITSTATUS
+(
+x
+�(
+	`_W_INT
+(x�>> 8)
+
+	)
+
+156 

+	#WSTOPSIG
+(
+x
+�(
+	`_W_INT
+(x�>> 8)
+
+	)
+
+157 

+	#WIFCONTINUED
+(
+x
+�(
+	`_WSTATUS
+(x�=�
+_WSTOPPED
+ && 
+	`WSTOPSIG
+(x�=�0x13)
+
+	)
+
+158 

+	#WIFSTOPPED
+(
+x
+�(
+	`_WSTATUS
+(x�=�
+_WSTOPPED
+ && 
+	`WSTOPSIG
+(x�!�0x13)
+
+	)
+
+159 

+	#WIFEXITED
+(
+x
+�(
+	`_WSTATUS
+(x�=�0)
+
+	)
+
+160 

+	#WIFSIGNALED
+(
+x
+�(
+	`_WSTATUS
+(x�!�
+_WSTOPPED
+ && _WSTATUS(x�!�0)
+
+	)
+
+161 

+	#WTERMSIG
+(
+x
+�(
+	`_WSTATUS
+(x))
+
+	)
+
+162 #i�(!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+))
+
+163 

+	#WCOREDUMP
+(
+x
+�(
+	`_W_INT
+(x�& 
+WCOREFLAG
+)
+
+	)
+
+165 

+	#W_EXITCODE
+(
+�t
+, 
+sig
+�(ԑ�<< 8 | (sig))
+
+	)
+
+166 

+	#W_STOPCODE
+(
+sig
+�((sig�<< 8 | 
+_WSTOPPED
+)
+
+	)
+
+175 

+	#WEXITED
+ 0x00000004
+
+	)
+
+176 #i�
+__DARWIN_UNIX03
+
+
+178 

+	#WSTOPPED
+ 0x00000008
+
+	)
+
+180 

+	#WCONTINUED
+ 0x00000010
+
+	)
+
+181 

+	#WNOWAIT
+ 0x00000020
+
+	)
+
+184 #i�(!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+))
+
+190 

+	#WAIT_ANY
+ (-1�
+
+	)
+
+191 

+	#WAIT_MYPGRP
+ 0
+
+	)
+
+193 
+	~<mach�e/�d�n.h
+>
+
+201 
+	uwa�
+ {
+
+202 
+	mw_��us
+;
+
+207 #i�
+__DARWIN_BYTE_ORDER
+ =�
+__DARWIN_LITTLE_ENDIAN
+
+
+208 
+	mw_T�msig
+:7,
+
+209 
+	mw_C�edump
+:1,
+
+210 
+	mw_R�code
+:8,
+
+211 
+	mw_F��r
+:16;
+
+213 #i�
+__DARWIN_BYTE_ORDER
+ =�
+__DARWIN_BIG_ENDIAN
+
+
+214 
+	mw_F��r
+:16,
+
+215 
+	mw_R�code
+:8,
+
+216 
+	mw_C�edump
+:1,
+
+217 
+	mw_T�msig
+:7;
+
+219 } 
+	mw_T
+;
+
+226 #i�
+__DARWIN_BYTE_ORDER
+ =�
+__DARWIN_LITTLE_ENDIAN
+
+
+227 
+	mw_St�v�
+:8,
+
+228 
+	mw_St�sig
+:8,
+
+229 
+	mw_F��r
+:16;
+
+231 #i�
+__DARWIN_BYTE_ORDER
+ =�
+__DARWIN_BIG_ENDIAN
+
+
+232 
+	mw_F��r
+:16,
+
+233 
+	mw_St�sig
+:8,
+
+234 
+	mw_St�v�
+:8;
+
+236 } 
+	mw_S
+;
+
+238 

+	#w_�rmsig
+ 
+w_T
+.
+w_T�msig
+
+
+	)
+
+239 

+	#w_c�edump
+ 
+w_T
+.
+w_C�edump
+
+
+	)
+
+240 

+	#w_�tcode
+ 
+w_T
+.
+w_R�code
+
+
+	)
+
+241 

+	#w_��v�
+ 
+w_S
+.
+w_St�v�
+
+
+	)
+
+242 

+	#w_��sig
+ 
+w_S
+.
+w_St�sig
+
+
+	)
+
+246 #i�!(
+__DARWIN_UNIX03
+ - 0)
+
+251 

+	#WSTOPPED
+ 
+_WSTOPPED
+
+
+	)
+
+254 
+__BEGIN_DECLS
+
+
+255 
+pid_t
+ 
+	$wa�
+(*�
+	`__DARWIN_ALIAS_C
+(
+wa�
+);
+
+256 
+pid_t
+ 
+	$wa�pid
+(
+pid_t
+, *, �
+	`__DARWIN_ALIAS_C
+(
+wa�pid
+);
+
+257 #i�de�
+_ANSI_SOURCE
+
+
+258 
+	$wa�id
+(
+idty�_t
+, 
+id_t
+, 
+sig�fo_t
+ *, �
+	`__DARWIN_ALIAS_C
+(
+wa�id
+);
+
+260 #i� (!
+	`def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+))
+
+261 
+pid_t
+ 
+	`wa�3
+(*, , 
+ru�ge
+ *);
+
+262 
+pid_t
+ 
+	`wa�4
+�id_t, *, , 
+ru�ge
+ *);
+
+264 
+__END_DECLS
+
+
+	@/usr/include/time.h
+
+63 #i�de�
+_TIME_H_
+
+
+64 

+	#_TIME_H_
+
+
+	)
+
+66 
+	~<_ty�s.h
+>
+
+68 

+	#__�ed_�ru�_time�ec
+
+
+	)
+
+69 
+	~<_�ru�s.h
+>
+
+71 #i�de�
+NULL
+
+
+72 

+	#NULL
+ 
+__DARWIN_NULL
+
+
+	)
+
+75 #i�def 
+_CLOCK_T
+
+
+76 

+	#_CLOCK_T
+
+
+	)
+
+77 
+__d�w�_�ock_t
+ 
+	t�ock_t
+;
+
+80 #i�def 
+_SIZE_T
+
+
+81 

+	#_SIZE_T
+
+
+	)
+
+82 
+__d�w�_size_t
+ 
+	tsize_t
+;
+
+85 #i�def 
+_TIME_T
+
+
+86 

+	#_TIME_T
+
+
+	)
+
+87 
+__d�w�_time_t
+ 
+	ttime_t
+;
+
+90 
+	stm
+ {
+
+91 
+	mtm_�c
+;
+
+92 
+	mtm_m�
+;
+
+93 
+	mtm_hour
+;
+
+94 
+	mtm_mday
+;
+
+95 
+	mtm_m�
+;
+
+96 
+	mtm_y�r
+;
+
+97 
+	mtm_wday
+;
+
+98 
+	mtm_yday
+;
+
+99 
+	mtm_isd�
+;
+
+100 
+	mtm_gmtoff
+;
+
+101 *
+	mtm_z�e
+;
+
+104 #i�
+__DARWIN_UNIX03
+
+
+105 

+	#CLOCKS_PER_SEC
+ 1000000
+
+	)
+
+107 
+	~<mach�e/_lim�s.h
+>
+
+109 

+	#CLOCKS_PER_SEC
+ (
+__DARWIN_CLK_TCK
+)
+
+	)
+
+112 #i�de�
+_ANSI_SOURCE
+
+
+113 
*
+tz�me
+[];
+
+116 

+g�d�e_�r
+;
+
+117 #i�
+__DARWIN_UNIX03
+
+
+118 

+timez�e
+ 
+__DARWIN_ALIAS
+(timezone);
+
+120 

+daylight
+;
+
+122 
+__BEGIN_DECLS
+
+
+123 *
+as�ime
+(cڡ 
+tm
+ *);
+
+124 
+�ock_t
+ 
+	$�ock
+(�
+	`__DARWIN_ALIAS
+(
+�ock
+);
+
+125 *
+	`�ime
+(cڡ 
+time_t
+ *);
+
+126 
+	`dif�ime
+(
+time_t
+,�ime_t);
+
+127 
+tm
+ *
+	`g�d�e
+(const *);
+
+128 
+tm
+ *
+	`gmtime
+(cڡ 
+time_t
+ *);
+
+129 
+tm
+ *
+	`lo��ime
+(cڡ 
+time_t
+ *);
+
+130 
+time_t
+ 
+	$mktime
+(
+tm
+ *�
+	`__DARWIN_ALIAS
+(
+mktime
+);
+
+131 
+size_t
+ 
+	$�r�ime
+(* 
+__��ri�
+, 
+size_t
+, cڡ * __��ri�, cڡ 
+tm
+ * __��ri��
+	`__DARWIN_ALIAS
+(
+�r�ime
+);
+
+132 *
+	$��time
+(cڡ * 
+__��ri�
+, cڡ * __��ri�, 
+tm
+ * __��ri��
+	`__DARWIN_ALIAS
+(
+��time
+);
+
+133 
+time_t
+ 
+	`time
+(time_t *);
+
+135 #i�de�
+_ANSI_SOURCE
+
+
+136 
+	`tz�t
+();
+
+140 *
+	`as�ime_r
+(cڡ 
+tm
+ * 
+__��ri�
+, * __restrict);
+
+141 *
+	`�ime_r
+(cڡ 
+time_t
+ *, *);
+
+142 
+tm
+ *
+	`gmtime_r
+(cڡ 
+time_t
+ * 
+__��ri�
+, tm * __restrict);
+
+143 
+tm
+ *
+	`lo��ime_r
+(cڡ 
+time_t
+ * 
+__��ri�
+, tm * __restrict);
+
+145 #i�!
+	`def�ed
+(
+_ANSI_SOURCE
+�&& (!def�ed(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+))
+
+146 
+time_t
+ 
+	`posix2time
+(time_t);
+
+147 #i�!
+__DARWIN_UNIX03
+
+
+148 *
+	`timez�e
+(, );
+
+150 
+	`tz�tw�l
+();
+
+151 
+time_t
+ 
+	`time2posix
+(time_t);
+
+152 
+time_t
+ 
+	`tim�o�l
+(
+tm
+ * const);
+
+153 
+time_t
+ 
+	`timegm
+(
+tm
+ * const);
+
+156 #i�!
+	`def�ed
+(
+_ANSI_SOURCE
+)
+
+157 
+	$�no��p
+(cڡ 
+time�ec
+ *, time�e�*�
+	`__DARWIN_ALIAS_C
+(
+�no��p
+);
+
+159 
+__END_DECLS
+
+
+161 #ifde�
+_USE_EXTENDED_LOCALES_
+
+
+162 
+	~<xlo��/_time.h
+>
+
+	@/usr/include/xlocale/_stdio.h
+
+24 #i�de�
+_XLOCALE__STDIO_H_
+
+
+25 

+	#_XLOCALE__STDIO_H_
+
+
+	)
+
+27 
+__BEGIN_DECLS
+
+
+28 
+	$a�r�tf_l
+(**, 
+lo��_t
+, const *, ...)
+
+29 
+	`__DARWIN_LDBL_COMPAT2
+(
+a�r�tf_l
+);
+
+30 
+	$�r�tf_l
+(
+FILE
+ * 
+__��ri�
+, 
+lo��_t
+, const * __restrict, ...)
+
+31 
+	`__DARWIN_LDBL_COMPAT2
+(
+�r�tf_l
+);
+
+32 
+	$fs�nf_l
+(
+FILE
+ * 
+__��ri�
+, 
+lo��_t
+, const * __restrict, ...)
+
+33 
+	`__DARWIN_LDBL_COMPAT2
+(
+fs�nf_l
+);
+
+34 
+	$��tf_l
+(
+lo��_t
+, cڡ * 
+__��ri�
+, ...)
+
+35 
+	`__DARWIN_LDBL_COMPAT2
+(
+��tf_l
+);
+
+36 
+	$s�nf_l
+(
+lo��_t
+, cڡ * 
+__��ri�
+, ...)
+
+37 
+	`__DARWIN_LDBL_COMPAT2
+(
+s�nf_l
+);
+
+38 
+	$���tf_l
+(* 
+__��ri�
+, 
+size_t
+, 
+lo��_t
+,
+
+39 cڡ * 
+__��ri�
+, ...�
+	`__DARWIN_LDBL_COMPAT2
+(
+���tf_l
+);
+
+40 
+	$�r�tf_l
+(* 
+__��ri�
+, 
+lo��_t
+, const * __restrict, ...)
+
+41 
+	`__DARWIN_LDBL_COMPAT2
+(
+�r�tf_l
+);
+
+42 
+	$ss�nf_l
+(cڡ * 
+__��ri�
+, 
+lo��_t
+, const * __restrict,
+
+43 ...�
+	`__DARWIN_LDBL_COMPAT2
+(
+ss�nf_l
+);
+
+44 
+	$va�r�tf_l
+(**, 
+lo��_t
+, cڡ *, 
+va_li�
+)
+
+45 
+	`__DARWIN_LDBL_COMPAT2
+(
+va�r�tf_l
+);
+
+46 
+	$v�r�tf_l
+(
+FILE
+ * 
+__��ri�
+, 
+lo��_t
+, const * __restrict,
+
+47 
+va_li�
+�
+	`__DARWIN_LDBL_COMPAT2
+(
+v�r�tf_l
+);
+
+48 
+	$vfs�nf_l
+(
+FILE
+ * 
+__��ri�
+, 
+lo��_t
+, const * __restrict,
+
+49 
+va_li�
+�
+	`__DARWIN_LDBL_COMPAT2
+(
+vfs�nf_l
+);
+
+50 
+	$v��tf_l
+(
+lo��_t
+, cڡ * 
+__��ri�
+, 
+va_li�
+)
+
+51 
+	`__DARWIN_LDBL_COMPAT2
+(
+v��tf_l
+);
+
+52 
+	$vs�nf_l
+(
+lo��_t
+, cڡ * 
+__��ri�
+, 
+va_li�
+)
+
+53 
+	`__DARWIN_LDBL_COMPAT2
+(
+vs�nf_l
+);
+
+54 
+	$v���tf_l
+(* 
+__��ri�
+, 
+size_t
+, 
+lo��_t
+,
+
+55 cڡ * 
+__��ri�
+, 
+va_li�
+)
+
+56 
+	`__DARWIN_LDBL_COMPAT2
+(
+v���tf_l
+);
+
+57 
+	$v�r�tf_l
+(* 
+__��ri�
+, 
+lo��_t
+, const * __restrict,
+
+58 
+va_li�
+�
+	`__DARWIN_LDBL_COMPAT2
+(
+v�r�tf_l
+);
+
+59 
+	$vss�nf_l
+(cڡ * 
+__��ri�
+, 
+lo��_t
+, const * __restrict,
+
+60 
+va_li�
+�
+	`__DARWIN_LDBL_COMPAT2
+(
+vss�nf_l
+);
+
+61 
+__END_DECLS
+
+
+	@/usr/include/xlocale/_stdlib.h
+
+24 #i�de�
+_XLOCALE__STDLIB_H_
+
+
+25 

+	#_XLOCALE__STDLIB_H_
+
+
+	)
+
+27 
+__BEGIN_DECLS
+
+
+28 
+�of_l
+(cڡ *, 
+lo��_t
+);
+
+29 
+�oi_l
+(cڡ *, 
+lo��_t
+);
+
+30 
+��_l
+(cڡ *, 
+lo��_t
+);
+
+31 #i�!
+__DARWIN_NO_LONG_LONG
+
+
+33 
+��l_l
+(cڡ *, 
+lo��_t
+);
+
+35 
+mb�n_l
+(cڡ *, 
+size_t
+, 
+lo��_t
+);
+
+36 
+size_t
+ 
+mb�owcs_l
+(
+wch�_t
+ * 
+__��ri�
+ , const * __restrict, size_t,
+
+37 
+lo��_t
+);
+
+38 
+mbtowc_l
+(
+wch�_t
+ * 
+__��ri�
+, cڡ * __��ri�, 
+size_t
+,
+
+39 
+lo��_t
+);
+
+40 
+	$��od_l
+(cڡ *, **, 
+lo��_t
+�
+	`__DARWIN_ALIAS
+(
+��od_l
+);
+
+41 
+	$��of_l
+(cڡ *, **, 
+lo��_t
+�
+	`__DARWIN_ALIAS
+(
+��of_l
+);
+
+42 
+	`���_l
+(cڡ *, **, , 
+lo��_t
+);
+
+44 
+	$���d_l
+(cڡ *, **, 
+lo��_t
+)
+
+45 
+	`__DARWIN_LDBL_COMPAT2
+(
+���d_l
+);
+
+47 
+	`���l_l
+(cڡ *, **, , 
+lo��_t
+);
+
+48 #i�!
+__DARWIN_NO_LONG_LONG
+
+
+50 
+	`��oq_l
+(cڡ *, **, , 
+lo��_t
+);
+
+53 
+	`��oul_l
+(cڡ *, **, , 
+lo��_t
+);
+
+55 
+	`��ou�_l
+(cڡ *, **, , 
+lo��_t
+);
+
+56 #i�!
+__DARWIN_NO_LONG_LONG
+
+
+58 
+	`��ouq_l
+(cڡ *, **, , 
+lo��_t
+);
+
+60 
+size_t
+ 
+	`wc�ombs_l
+(* 
+__��ri�
+, cڡ 
+wch�_t
+ * __restrict, size_t,
+
+61 
+lo��_t
+);
+
+62 
+	`w�omb_l
+(*, 
+wch�_t
+, 
+lo��_t
+);
+
+65 #i�!
+	`def�ed
+(
+__�lu�lus
+�&& def�ed(
+__WCHAR_MAX__
+) && __WCHAR_MAX__ <= 0xffffU
+
+66 #�agm�
+GCC
+ 
+pois�
+ 
+mb�owcs_l
+ 
+mbtowc_l
+ 
+wc�ombs_l
+ 
+w�omb_l
+
+
+68 
+__END_DECLS
+
+
+	@/usr/include/_structs.h
+
+24 
+	~<sys/_�ru�s.h
+>
+
+	@/usr/include/i386/endian.h
+
+66 #i�de�
+_I386__ENDIAN_H_
+
+
+67 

+	#_I386__ENDIAN_H_
+
+
+	)
+
+69 
+	~<sys/cdefs.h
+>
+
+78 

+	#_QUAD_HIGHWORD
+ 1
+
+	)
+
+79 

+	#_QUAD_LOWWORD
+ 0
+
+	)
+
+85 

+	#__DARWIN_LITTLE_ENDIAN
+ 1234
+
+	)
+
+86 

+	#__DARWIN_BIG_ENDIAN
+ 4321
+
+	)
+
+87 

+	#__DARWIN_PDP_ENDIAN
+ 3412
+
+	)
+
+89 

+	#__DARWIN_BYTE_ORDER
+ 
+__DARWIN_LITTLE_ENDIAN
+
+
+	)
+
+91 #if 
+def�ed
+(
+KERNEL
+�|| (!def�ed(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+))
+
+93 

+	#LITTLE_ENDIAN
+ 
+__DARWIN_LITTLE_ENDIAN
+
+
+	)
+
+94 

+	#BIG_ENDIAN
+ 
+__DARWIN_BIG_ENDIAN
+
+
+	)
+
+95 

+	#PDP_ENDIAN
+ 
+__DARWIN_PDP_ENDIAN
+
+
+	)
+
+97 

+	#BYTE_ORDER
+ 
+__DARWIN_BYTE_ORDER
+
+
+	)
+
+99 
+	~<sys/_�d�n.h
+>
+
+	@/usr/include/i386/types.h
+
+66 #i�def 
+_MACHTYPES_H_
+
+
+67 

+	#_MACHTYPES_H_
+
+
+	)
+
+69 #i�de�
+__ASSEMBLER__
+
+
+70 
+	~<i386/_ty�s.h
+>
+
+71 
+	~<sys/cdefs.h
+>
+
+76 #i�de�
+_INT8_T
+
+
+77 

+	#_INT8_T
+
+
+	)
+
+78 
+__sig�d
+ 
+	t�t8_t
+;
+
+80 
+	tu_�t8_t
+;
+
+81 #i�de�
+_INT16_T
+
+
+82 

+	#_INT16_T
+
+
+	)
+
+83 
+	t�t16_t
+;
+
+85 
+	tu_�t16_t
+;
+
+86 #i�de�
+_INT32_T
+
+
+87 

+	#_INT32_T
+
+
+	)
+
+88 
+	t�t32_t
+;
+
+90 
+	tu_�t32_t
+;
+
+91 #i�de�
+_INT64_T
+
+
+92 

+	#_INT64_T
+
+
+	)
+
+93 
+	t�t64_t
+;
+
+95 
+	tu_�t64_t
+;
+
+97 #i�
+__LP64__
+
+
+98 
+�t64_t
+ 
+	t�gi��_t
+;
+
+100 
+�t32_t
+ 
+	t�gi��_t
+;
+
+103 #i�de�
+_INTPTR_T
+
+
+104 

+	#_INTPTR_T
+
+
+	)
+
+105 
+__d�w�_���_t
+ 
+	t���_t
+;
+
+107 #i�de�
+_UINTPTR_T
+
+
+108 

+	#_UINTPTR_T
+
+
+	)
+
+109 
+	tu���_t
+;
+
+112 #i�!
+def�ed
+(
+_ANSI_SOURCE
+�&& (!def�ed(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+))
+
+114 
+u_�t64_t
+ 
+	tu�r_addr_t
+;
+
+115 
+u_�t64_t
+ 
+	tu�r_size_t
+;
+
+116 
+�t64_t
+ 
+	tu�r_ssize_t
+;
+
+117 
+�t64_t
+ 
+	tu�r_l�g_t
+;
+
+118 
+u_�t64_t
+ 
+	tu�r_ul�g_t
+;
+
+119 
+�t64_t
+ 
+	tu�r_time_t
+;
+
+120 

+	#USER_ADDR_NULL
+ ((
+u�r_addr_t
+�0)
+
+	)
+
+121 

+	#CAST_USER_ADDR_T
+(
+a_�r
+�((
+u�r_addr_t
+)((
+u���_t
+)�_�r)))
+
+	)
+
+125 
+u_�t64_t
+ 
+	tsys��_�g_t
+;
+
+127 #i�de�
+__off�tof
+
+
+128 

+	#__off�tof
+(
+ty�
+, 
+f�ld
+�((
+size_t
+)(&(�y� *)0)->f�ld))
+
+	)
+
+	@/usr/include/machine/_limits.h
+
+28 #i�de�
+_BSD_MACHINE__LIMITS_H_
+
+
+29 

+	#_BSD_MACHINE__LIMITS_H_
+
+
+	)
+
+31 #i�
+def�ed
+ (
+__�c__
+�|| def�ed (
+__�c64__
+)
+
+32 
+	~"�c/_lim�s.h
+"
+
+33 #�i�
+def�ed
+ (
+__i386__
+�|| def�ed(
+__x86_64__
+)
+
+34 
+	~"i386/_lim�s.h
+"
+
+35 #�i�
+def�ed
+ (
+__�m__
+)
+
+36 
+	~"�m/_lim�s.h
+"
+
+38 #�r� 
+�ch�e�u�
+ 
+n�
+ 
+su�܋d
+
+
+	@/usr/include/machine/_structs.h
+
+28 #i�
+def�ed
+ (
+__�c__
+�|| def�ed (
+__�c64__
+)
+
+29 
+	~"�c/_�ru�s.h
+"
+
+30 #�i�
+def�ed
+ (
+__i386__
+�|| def�ed (
+__x86_64__
+)
+
+31 
+	~"i386/_�ru�s.h
+"
+
+32 #�i�
+def�ed
+ (
+__�m__
+)
+
+33 
+	~"�m/_�ru�s.h
+"
+
+35 #�r� 
+�ch�e�u�
+ 
+n�
+ 
+su�܋d
+
+
+	@/usr/include/machine/_types.h
+
+28 #i�de�
+_BSD_MACHINE__TYPES_H_
+
+
+29 

+	#_BSD_MACHINE__TYPES_H_
+
+
+	)
+
+31 #i�
+def�ed
+ (
+__�c__
+�|| def�ed (
+__�c64__
+)
+
+32 
+	~"�c/_ty�s.h
+"
+
+33 #�i�
+def�ed
+ (
+__i386__
+�|| def�ed(
+__x86_64__
+)
+
+34 
+	~"i386/_ty�s.h
+"
+
+35 #�i�
+def�ed
+ (
+__�m__
+)
+
+36 
+	~"�m/_ty�s.h
+"
+
+38 #�r� 
+�ch�e�u�
+ 
+n�
+ 
+su�܋d
+
+
+	@/usr/include/ppc/endian.h
+
+92 #i�de�
+_PPC_ENDIAN_H_
+
+
+93 

+	#_PPC_ENDIAN_H_
+
+
+	)
+
+95 
+	~<sys/cdefs.h
+>
+
+100 

+	#_QUAD_HIGHWORD
+ 0
+
+	)
+
+101 

+	#_QUAD_LOWWORD
+ 1
+
+	)
+
+107 

+	#__DARWIN_LITTLE_ENDIAN
+ 1234
+
+	)
+
+108 

+	#__DARWIN_BIG_ENDIAN
+ 4321
+
+	)
+
+109 

+	#__DARWIN_PDP_ENDIAN
+ 3412
+
+	)
+
+111 

+	#__DARWIN_BYTE_ORDER
+ 
+__DARWIN_BIG_ENDIAN
+
+
+	)
+
+113 #if 
+def�ed
+(
+KERNEL
+�|| (!def�ed(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+))
+
+115 

+	#LITTLE_ENDIAN
+ 
+__DARWIN_LITTLE_ENDIAN
+
+
+	)
+
+116 

+	#BIG_ENDIAN
+ 
+__DARWIN_BIG_ENDIAN
+
+
+	)
+
+117 

+	#PDP_ENDIAN
+ 
+__DARWIN_PDP_ENDIAN
+
+
+	)
+
+119 

+	#BYTE_ORDER
+ 
+__DARWIN_BYTE_ORDER
+
+
+	)
+
+121 
+	~<sys/_�d�n.h
+>
+
+	@/usr/include/ppc/types.h
+
+66 #i�def 
+_MACHTYPES_H_
+
+
+67 

+	#_MACHTYPES_H_
+
+
+	)
+
+69 #i�de�
+__ASSEMBLER__
+
+
+70 
+	~<�c/_ty�s.h
+>
+
+71 
+	~<sys/cdefs.h
+>
+
+76 #i�de�
+_INT8_T
+
+
+77 

+	#_INT8_T
+
+
+	)
+
+78 
+__sig�d
+ 
+	t�t8_t
+;
+
+80 
+	tu_�t8_t
+;
+
+81 #i�de�
+_INT16_T
+
+
+82 

+	#_INT16_T
+
+
+	)
+
+83 
+	t�t16_t
+;
+
+85 
+	tu_�t16_t
+;
+
+86 #i�de�
+_INT32_T
+
+
+87 

+	#_INT32_T
+
+
+	)
+
+88 
+	t�t32_t
+;
+
+90 
+	tu_�t32_t
+;
+
+91 #i�de�
+_INT64_T
+
+
+92 

+	#_INT64_T
+
+
+	)
+
+93 
+	t�t64_t
+;
+
+95 
+	tu_�t64_t
+;
+
+97 #i�
+def�ed
+(
+__�c64__
+)
+
+98 
+�t64_t
+ 
+	t�gi��_t
+;
+
+100 
+�t32_t
+ 
+	t�gi��_t
+;
+
+103 #i�de�
+_INTPTR_T
+
+
+104 

+	#_INTPTR_T
+
+
+	)
+
+105 
+__d�w�_���_t
+ 
+	t���_t
+;
+
+107 #i�de�
+_UINTPTR_T
+
+
+108 

+	#_UINTPTR_T
+
+
+	)
+
+109 
+	tu���_t
+;
+
+112 #i�!
+def�ed
+(
+_ANSI_SOURCE
+�&& (!def�ed(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+))
+
+117 
+u_�t64_t
+ 
+	tu�r_addr_t
+;
+
+118 
+u_�t64_t
+ 
+	tu�r_size_t
+;
+
+119 
+�t64_t
+ 
+	tu�r_ssize_t
+;
+
+120 
+�t64_t
+ 
+	tu�r_l�g_t
+;
+
+121 
+u_�t64_t
+ 
+	tu�r_ul�g_t
+;
+
+122 
+�t64_t
+ 
+	tu�r_time_t
+;
+
+123 

+	#USER_ADDR_NULL
+ ((
+u�r_addr_t
+�0)
+
+	)
+
+124 

+	#CAST_USER_ADDR_T
+(
+a_�r
+�((
+u�r_addr_t
+)((
+u���_t
+)�_�r)))
+
+	)
+
+128 
+u_�t64_t
+ 
+	tsys��_�g_t
+;
+
+130 #i�de�
+__off�tof
+
+
+131 

+	#__off�tof
+(
+ty�
+, 
+f�ld
+�((
+size_t
+)(&(�y� *)0)->f�ld))
+
+	)
+
+	@/usr/include/secure/_common.h
+
+24 #i�de�
+_SECURE__COMMON_H_
+
+
+25 

+	#_SECURE__COMMON_H_
+
+
+	)
+
+27 #unde�
+_USE_FORTIFY_LEVEL
+
+
+28 #ifde�
+_FORTIFY_SOURCE
+ && _FORTIFY_SOURCE > 0
+
+29 #i�
+_FORTIFY_SOURCE
+ > 1
+
+30 

+	#_USE_FORTIFY_LEVEL
+ 2
+
+	)
+
+32 

+	#_USE_FORTIFY_LEVEL
+ 1
+
+	)
+
+35 

+	#_USE_FORTIFY_LEVEL
+ 0
+
+	)
+
+38 

+	#__d�w�_obsz0
+(
+obje�
+�
+	`__bu�t�_obje�_size
+ (obje�, 0)
+
+	)
+
+39 

+	#__d�w�_obsz
+(
+obje�
+�
+	`__bu�t�_obje�_size
+ (obje�, 
+_USE_FORTIFY_LEVEL
+ > 1)
+
+	)
+
+	@/usr/include/sys/resource.h
+
+64 #i�de�
+_SYS_RESOURCE_H_
+
+
+65 

+	#_SYS_RESOURCE_H_
+
+
+	)
+
+67 
+	~<sys/���pi�ts.h
+>
+
+68 
+	~<sys/cdefs.h
+>
+
+69 
+	~<sys/_ty�s.h
+>
+
+75 

+	#__�ed_�ru�_timev�
+
+
+	)
+
+76 
+	~<sys/_�ru�s.h
+>
+
+79 #i�de�
+_ID_T
+
+
+80 

+	#_ID_T
+
+
+	)
+
+81 
+__d�w�_id_t
+ 
+	tid_t
+;
+
+88 
+__u�t64_t
+ 
+	t�im_t
+;
+
+99 

+	#PRIO_PROCESS
+ 0
+
+	)
+
+100 

+	#PRIO_PGRP
+ 1
+
+	)
+
+101 

+	#PRIO_USER
+ 2
+
+	)
+
+103 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+104 

+	#PRIO_DARWIN_THREAD
+ 3
+
+	)
+
+109 

+	#PRIO_MIN
+ -20
+
+	)
+
+110 

+	#PRIO_MAX
+ 20
+
+	)
+
+116 

+	#PRIO_DARWIN_BG
+ 0x1000
+
+	)
+
+130 

+	#RUSAGE_SELF
+ 0
+
+	)
+
+131 

+	#RUSAGE_CHILDREN
+ -1
+
+	)
+
+142 
+	sru�ge
+ {
+
+143 
+timev�
+ 
+	mru_utime
+;
+
+144 
+timev�
+ 
+	mru_�ime
+;
+
+145 #i�
+def�ed
+(
+_POSIX_C_SOURCE
+�&& !def�ed(
+_DARWIN_C_SOURCE
+)
+
+146 
+	mru_�aque
+[14];
+
+153 
+	mru_maxrss
+;
+
+154 

+	#ru_f��
+ 
+ru_ixrss
+
+
+	)
+
+155 
+	mru_ixrss
+;
+
+156 
+	mru_idrss
+;
+
+157 
+	mru_i�ss
+;
+
+158 
+	mru_m��t
+;
+
+159 
+	mru_maj�t
+;
+
+160 
+	mru_nsw�
+;
+
+161 
+	mru_�block
+;
+
+162 
+	mru_oublock
+;
+
+163 
+	mru_msg�d
+;
+
+164 
+	mru_msgrcv
+;
+
+165 
+	mru_nsig�ls
+;
+
+166 
+	mru_nvcsw
+;
+
+167 
+	mru_nivcsw
+;
+
+168 

+	#ru_ϡ
+ 
+ru_nivcsw
+
+
+	)
+
+184 

+	#RLIM_INFINITY
+ (((
+__u�t64_t
+)1 << 63�- 1�
+
+	)
+
+185 

+	#RLIM_SAVED_MAX
+ 
+RLIM_INFINITY
+
+
+	)
+
+186 

+	#RLIM_SAVED_CUR
+ 
+RLIM_INFINITY
+
+
+	)
+
+192 

+	#RLIMIT_CPU
+ 0
+
+	)
+
+193 

+	#RLIMIT_FSIZE
+ 1
+
+	)
+
+194 

+	#RLIMIT_DATA
+ 2
+
+	)
+
+195 

+	#RLIMIT_STACK
+ 3
+
+	)
+
+196 

+	#RLIMIT_CORE
+ 4
+
+	)
+
+197 

+	#RLIMIT_AS
+ 5
+
+	)
+
+198 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+199 

+	#RLIMIT_RSS
+ 
+RLIMIT_AS
+
+
+	)
+
+200 

+	#RLIMIT_MEMLOCK
+ 6
+
+	)
+
+201 

+	#RLIMIT_NPROC
+ 7
+
+	)
+
+203 

+	#RLIMIT_NOFILE
+ 8
+
+	)
+
+204 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+205 

+	#RLIM_NLIMITS
+ 9
+
+	)
+
+207 

+	#_RLIMIT_POSIX_FLAG
+ 0x1000
+
+	)
+
+213 
+	s�im�
+ {
+
+214 
+�im_t
+ 
+	m�im_cur
+;
+
+215 
+�im_t
+ 
+	m�im_max
+;
+
+218 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+220 

+	#IOPOL_TYPE_DISK
+ 0
+
+	)
+
+223 

+	#IOPOL_SCOPE_PROCESS
+ 0
+
+	)
+
+224 

+	#IOPOL_SCOPE_THREAD
+ 1
+
+	)
+
+227 

+	#IOPOL_DEFAULT
+ 0
+
+	)
+
+228 

+	#IOPOL_NORMAL
+ 1
+
+	)
+
+229 

+	#IOPOL_PASSIVE
+ 2
+
+	)
+
+230 

+	#IOPOL_THROTTLE
+ 3
+
+	)
+
+235 
+__BEGIN_DECLS
+
+
+236 
+g��iܙy
+(, 
+id_t
+);
+
+237 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+238 
+g�i��icy_�
+(, );
+
+240 
+	$g��im�
+(, 
+�im�
+ *�
+	`__DARWIN_ALIAS
+(
+g��im�
+);
+
+241 
+	`g�ru�ge
+(, 
+ru�ge
+ *);
+
+242 
+	`��riܙy
+(, 
+id_t
+, );
+
+243 #i�!
+	`def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+244 
+	`�ti��icy_�
+(, , );
+
+246 
+	$��lim�
+(, cڡ 
+�im�
+ *�
+	`__DARWIN_ALIAS
+(
+��lim�
+);
+
+247 
+__END_DECLS
+
+
+	@/usr/include/sys/signal.h
+
+69 #i�def 
+_SYS_SIGNAL_H_
+
+
+70 

+	#_SYS_SIGNAL_H_
+
+
+	)
+
+72 
+	~<sys/cdefs.h
+>
+
+73 
+	~<sys/���pi�ts.h
+>
+
+75 

+	#__DARWIN_NSIG
+ 32
+
+	)
+
+77 #i�!
+def�ed
+(
+_ANSI_SOURCE
+�&& (!def�ed(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+))
+
+78 

+	#NSIG
+ 
+__DARWIN_NSIG
+
+
+	)
+
+81 
+	~<mach�e/sig�l.h
+>
+
+83 

+	#SIGHUP
+ 1
+
+	)
+
+84 

+	#SIGINT
+ 2
+
+	)
+
+85 

+	#SIGQUIT
+ 3
+
+	)
+
+86 

+	#SIGILL
+ 4
+
+	)
+
+87 

+	#SIGTRAP
+ 5
+
+	)
+
+88 

+	#SIGABRT
+ 6
+
+	)
+
+89 #i� (
+def�ed
+(
+_POSIX_C_SOURCE
+�&& !def�ed(
+_DARWIN_C_SOURCE
+))
+
+90 

+	#SIGPOLL
+ 7
+
+	)
+
+92 

+	#SIGIOT
+ 
+SIGABRT
+
+
+	)
+
+93 

+	#SIGEMT
+ 7
+
+	)
+
+95 

+	#SIGFPE
+ 8
+
+	)
+
+96 

+	#SIGKILL
+ 9
+
+	)
+
+97 

+	#SIGBUS
+ 10
+
+	)
+
+98 

+	#SIGSEGV
+ 11
+
+	)
+
+99 

+	#SIGSYS
+ 12
+
+	)
+
+100 

+	#SIGPIPE
+ 13
+
+	)
+
+101 

+	#SIGALRM
+ 14
+
+	)
+
+102 

+	#SIGTERM
+ 15
+
+	)
+
+103 

+	#SIGURG
+ 16
+
+	)
+
+104 

+	#SIGSTOP
+ 17
+
+	)
+
+105 

+	#SIGTSTP
+ 18
+
+	)
+
+106 

+	#SIGCONT
+ 19
+
+	)
+
+107 

+	#SIGCHLD
+ 20
+
+	)
+
+108 

+	#SIGTTIN
+ 21
+
+	)
+
+109 

+	#SIGTTOU
+ 22
+
+	)
+
+110 #i� (!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+))
+
+111 

+	#SIGIO
+ 23
+
+	)
+
+113 

+	#SIGXCPU
+ 24
+
+	)
+
+114 

+	#SIGXFSZ
+ 25
+
+	)
+
+115 

+	#SIGVTALRM
+ 26
+
+	)
+
+116 

+	#SIGPROF
+ 27
+
+	)
+
+117 #i� (!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+))
+
+118 

+	#SIGWINCH
+ 28
+
+	)
+
+119 

+	#SIGINFO
+ 29
+
+	)
+
+121 

+	#SIGUSR1
+ 30
+
+	)
+
+122 

+	#SIGUSR2
+ 31
+
+	)
+
+124 #i�
+def�ed
+(
+_ANSI_SOURCE
+�|| 
+__DARWIN_UNIX03
+ || def�ed(
+__�lu�lus
+)
+
+130 

+	#SIG_DFL
+ ((*)())0
+
+	)
+
+131 

+	#SIG_IGN
+ ((*)())1
+
+	)
+
+132 

+	#SIG_HOLD
+ ((*)())5
+
+	)
+
+133 

+	#SIG_ERR
+ (((*)())-1)
+
+	)
+
+136 

+	#SIG_DFL
+ ((*)�))0
+
+	)
+
+137 

+	#SIG_IGN
+ ((*)�))1
+
+	)
+
+138 

+	#SIG_HOLD
+ ((*)�))5
+
+	)
+
+139 

+	#SIG_ERR
+ (((*)�))-1)
+
+	)
+
+142 #i�de�
+_ANSI_SOURCE
+
+
+143 
+	~<sys/_ty�s.h
+>
+
+145 

+	#__�ed_mcڋxt_t
+
+
+	)
+
+146 

+	#__�ed_�ack_t
+
+
+	)
+
+147 

+	#__�ed_ucڋxt_t
+
+
+	)
+
+148 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+149 #i�
+def�ed
+(
+__�c__
+�|| def�ed(
+__�c64__
+)
+
+150 

+	#__�ed_mcڋxt64_t
+
+
+	)
+
+151 

+	#__�ed_ucڋxt64_t
+
+
+	)
+
+154 
+	~<sys/_�ru�s.h
+>
+
+156 #i�de�
+_PID_T
+
+
+157 

+	#_PID_T
+
+
+	)
+
+158 
+__d�w�_pid_t
+ 
+	tpid_t
+;
+
+161 #i�de�
+_PTHREAD_ATTR_T
+
+
+162 

+	#_PTHREAD_ATTR_T
+
+
+	)
+
+163 
+__d�w�_�h�ad_��_t
+ 
+	t�h�ad_��_t
+;
+
+166 #i�de�
+_SIGSET_T
+
+
+167 

+	#_SIGSET_T
+
+
+	)
+
+168 
+__d�w�_sig�t_t
+ 
+	tsig�t_t
+;
+
+171 #i�def 
+_SIZE_T
+
+
+172 

+	#_SIZE_T
+
+
+	)
+
+173 
+__d�w�_size_t
+ 
+	tsize_t
+;
+
+176 #i�de�
+_UID_T
+
+
+177 

+	#_UID_T
+
+
+	)
+
+178 
+__d�w�_uid_t
+ 
+	tuid_t
+;
+
+181 
+	usigv�
+ {
+
+183 
+	msiv�_�t
+;
+
+184 *
+	msiv�_�r
+;
+
+187 

+	#SIGEV_NONE
+ 0
+
+	)
+
+188 

+	#SIGEV_SIGNAL
+ 1
+
+	)
+
+189 

+	#SIGEV_THREAD
+ 3
+
+	)
+
+191 
+	ssigev�t
+ {
+
+192 
+	msigev_n�ify
+;
+
+193 
+	msigev_signo
+;
+
+194 
+sigv�
+ 
+	msigev_v�ue
+;
+
+195 (*
+	msigev_n�ify_fun�i�
+)(
+	msigv�
+);
+
+196 
+�h�ad_��_t
+ *
+	msigev_n�ify_��ibu�s
+;
+
+200 
+	s__sig�fo
+ {
+
+201 
+	msi_signo
+;
+
+202 
+	msi_��o
+;
+
+203 
+	msi_code
+;
+
+204 
+pid_t
+ 
+	msi_pid
+;
+
+205 
+uid_t
+ 
+	msi_uid
+;
+
+206 
+	msi_��us
+;
+
+207 *
+	msi_addr
+;
+
+208 
+sigv�
+ 
+	msi_v�ue
+;
+
+209 
+	msi_b�d
+;
+
+210 
+	m__�d
+[7];
+
+211 } 
+	tsig�fo_t
+;
+
+228 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+229 

+	#ILL_NOOP
+ 0
+
+	)
+
+231 

+	#ILL_ILLOPC
+ 1
+
+	)
+
+232 

+	#ILL_ILLTRP
+ 2
+
+	)
+
+233 

+	#ILL_PRVOPC
+ 3
+
+	)
+
+234 

+	#ILL_ILLOPN
+ 4
+
+	)
+
+235 

+	#ILL_ILLADR
+ 5
+
+	)
+
+236 

+	#ILL_PRVREG
+ 6
+
+	)
+
+237 

+	#ILL_COPROC
+ 7
+
+	)
+
+238 

+	#ILL_BADSTK
+ 8
+
+	)
+
+241 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+242 

+	#FPE_NOOP
+ 0
+
+	)
+
+244 

+	#FPE_FLTDIV
+ 1
+
+	)
+
+245 

+	#FPE_FLTOVF
+ 2
+
+	)
+
+246 

+	#FPE_FLTUND
+ 3
+
+	)
+
+247 

+	#FPE_FLTRES
+ 4
+
+	)
+
+248 

+	#FPE_FLTINV
+ 5
+
+	)
+
+249 

+	#FPE_FLTSUB
+ 6
+
+	)
+
+250 

+	#FPE_INTDIV
+ 7
+
+	)
+
+251 

+	#FPE_INTOVF
+ 8
+
+	)
+
+254 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+255 

+	#SEGV_NOOP
+ 0
+
+	)
+
+257 

+	#SEGV_MAPERR
+ 1
+
+	)
+
+258 

+	#SEGV_ACCERR
+ 2
+
+	)
+
+261 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+262 

+	#BUS_NOOP
+ 0
+
+	)
+
+264 

+	#BUS_ADRALN
+ 1
+
+	)
+
+265 

+	#BUS_ADRERR
+ 2
+
+	)
+
+266 

+	#BUS_OBJERR
+ 3
+
+	)
+
+269 

+	#TRAP_BRKPT
+ 1
+
+	)
+
+270 

+	#TRAP_TRACE
+ 2
+
+	)
+
+273 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+274 

+	#CLD_NOOP
+ 0
+
+	)
+
+276 

+	#CLD_EXITED
+ 1
+
+	)
+
+277 

+	#CLD_KILLED
+ 2
+
+	)
+
+278 

+	#CLD_DUMPED
+ 3
+
+	)
+
+279 

+	#CLD_TRAPPED
+ 4
+
+	)
+
+280 

+	#CLD_STOPPED
+ 5
+
+	)
+
+281 

+	#CLD_CONTINUED
+ 6
+
+	)
+
+284 

+	#POLL_IN
+ 1
+
+	)
+
+285 

+	#POLL_OUT
+ 2
+
+	)
+
+286 

+	#POLL_MSG
+ 3
+
+	)
+
+287 

+	#POLL_ERR
+ 4
+
+	)
+
+288 

+	#POLL_PRI
+ 5
+
+	)
+
+289 

+	#POLL_HUP
+ 6
+
+	)
+
+292 
+	u__siga�i�_u
+ {
+
+293 (*
+	m__�_h�d�r
+)();
+
+294 (*
+	m__�_siga�i�
+)(, 
+	m__sig�fo
+ *,
+
+299 
+	s__siga�i�
+ {
+
+300 
+__siga�i�_u
+ 
+	m__siga�i�_u
+;
+
+301 (*
+	m�_�amp
+)(*, , , 
+	msig�fo_t
+ *, *);
+
+302 
+sig�t_t
+ 
+	m�_mask
+;
+
+303 
+	m�_�ags
+;
+
+309 
+	ssiga�i�
+ {
+
+310 
+__siga�i�_u
+ 
+	m__siga�i�_u
+;
+
+311 
+sig�t_t
+ 
+	m�_mask
+;
+
+312 
+	m�_�ags
+;
+
+318 

+	#�_h�d�r
+ 
+__siga�i�_u
+.
+__�_h�d�r
+
+
+	)
+
+319 

+	#�_siga�i�
+ 
+__siga�i�_u
+.
+__�_siga�i�
+
+
+	)
+
+321 

+	#SA_ONSTACK
+ 0x0001
+
+	)
+
+322 

+	#SA_RESTART
+ 0x0002
+
+	)
+
+323 

+	#SA_RESETHAND
+ 0x0004
+
+	)
+
+324 

+	#SA_NOCLDSTOP
+ 0x0008
+
+	)
+
+325 

+	#SA_NODEFER
+ 0x0010
+
+	)
+
+326 

+	#SA_NOCLDWAIT
+ 0x0020
+
+	)
+
+327 

+	#SA_SIGINFO
+ 0x0040
+
+	)
+
+328 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+329 

+	#SA_USERTRAMP
+ 0x0100
+
+	)
+
+331 

+	#SA_64REGSET
+ 0x0200
+
+	)
+
+337 

+	#SA_USERSPACE_MASK
+ (
+SA_ONSTACK
+ | 
+SA_RESTART
+ | 
+SA_RESETHAND
+ | 
+SA_NOCLDSTOP
+ | 
+SA_NODEFER
+ | 
+SA_NOCLDWAIT
+ | 
+SA_SIGINFO
+)
+
+	)
+
+342 

+	#SIG_BLOCK
+ 1
+
+	)
+
+343 

+	#SIG_UNBLOCK
+ 2
+
+	)
+
+344 

+	#SIG_SETMASK
+ 3
+
+	)
+
+347 

+	#SI_USER
+ 0x10001
+
+	)
+
+348 

+	#SI_QUEUE
+ 0x10002
+
+	)
+
+349 

+	#SI_TIMER
+ 0x10003
+
+	)
+
+350 

+	#SI_ASYNCIO
+ 0x10004
+
+	)
+
+351 

+	#SI_MESGQ
+ 0x10005
+
+	)
+
+353 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+354 (*
+	tsig_t
+)();
+
+361 

+	#SS_ONSTACK
+ 0x0001
+
+	)
+
+362 

+	#SS_DISABLE
+ 0x0004
+
+	)
+
+363 

+	#MINSIGSTKSZ
+ 32768
+
+	)
+
+364 

+	#SIGSTKSZ
+ 131072
+
+	)
+
+366 #i�!
+	`def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+371 
+	ssigvec
+ {
+
+372 (*
+sv_h�d�r
+)();
+
+373 
+sv_mask
+;
+
+374 
+sv_�ags
+;
+
+377 

+	#SV_ONSTACK
+ 
+SA_ONSTACK
+
+
+	)
+
+378 

+	#SV_INTERRUPT
+ 
+SA_RESTART
+
+
+	)
+
+379 

+	#SV_RESETHAND
+ 
+SA_RESETHAND
+
+
+	)
+
+380 

+	#SV_NODEFER
+ 
+SA_NODEFER
+
+
+	)
+
+381 

+	#SV_NOCLDSTOP
+ 
+SA_NOCLDSTOP
+
+
+	)
+
+382 

+	#SV_SIGINFO
+ 
+SA_SIGINFO
+
+
+	)
+
+384 

+	#sv_ڡack
+ 
+sv_�ags
+
+
+	)
+
+390 
+	ssig�ack
+ {
+
+391 *
+ss_�
+;
+
+392 
+ss_ڡack
+;
+
+395 #i�!
+	`def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+400 

+	#sigmask
+(
+m
+�(1 << ((m)-1))
+
+	)
+
+403 

+	#BADSIG
+ 
+SIG_ERR
+
+
+	)
+
+412 
+__BEGIN_DECLS
+
+
+413 (*
+	`sig�l
+(, (*)()))();
+
+414 
+__END_DECLS
+
+
+	@/usr/include/xlocale/_time.h
+
+24 #i�de�
+_XLOCALE__TIME_H_
+
+
+25 

+	#_XLOCALE__TIME_H_
+
+
+	)
+
+27 
+__BEGIN_DECLS
+
+
+28 
+size_t
+ 
+	$�r�ime_l
+(* 
+__��ri�
+, 
+size_t
+, const * __restrict,
+
+29 cڡ 
+tm
+ * 
+__��ri�
+, 
+lo��_t
+)
+
+30 
+	`__DARWIN_ALIAS
+(
+�r�ime_l
+);
+
+31 *
+	$��time_l
+(cڡ * 
+__��ri�
+, const * __restrict,
+
+32 
+tm
+ * 
+__��ri�
+, 
+lo��_t
+�
+	`__DARWIN_ALIAS
+(
+��time_l
+);
+
+33 
+__END_DECLS
+
+
+	@/usr/include/i386/_limits.h
+
+22 #i�def 
+_I386__LIMITS_H_
+
+
+23 

+	#_I386__LIMITS_H_
+
+
+	)
+
+25 

+	#__DARWIN_CLK_TCK
+ 100
+
+	)
+
+	@/usr/include/i386/_structs.h
+
+29 
+	~<sys/���pi�ts.h
+>
+
+31 #ifde�
+__�ed_mcڋxt_t
+
+
+32 #i�de�
+__�ed_�ru�_mcڋxt
+
+
+33 

+	#__�ed_�ru�_mcڋxt
+
+
+	)
+
+37 #i�
+def�ed
+(
+__�ed_�ru�_mcڋxt
+)
+
+38 
+	~<mach/i386/_�ru�s.h
+>
+
+42 #ifde�
+__�ed_�ru�_mcڋxt
+
+
+43 #unde�
+__�ed_�ru�_mcڋxt
+
+
+45 #i�de�
+_STRUCT_MCONTEXT32
+
+
+46 #i�
+__DARWIN_UNIX03
+
+
+47 

+	#_STRUCT_MCONTEXT32
+ 
+__d�w�_mcڋxt32
+
+
+	)
+
+48 
+	g_STRUCT_MCONTEXT32
+
+
+50 
+_STRUCT_X86_EXCEPTION_STATE32
+ 
+	g__es
+;
+
+51 
+_STRUCT_X86_THREAD_STATE32
+ 
+	g__ss
+;
+
+52 
+_STRUCT_X86_FLOAT_STATE32
+ 
+	g__fs
+;
+
+55 

+	#_STRUCT_MCONTEXT32
+ 
+mcڋxt32
+
+
+	)
+
+56 
+	g_STRUCT_MCONTEXT32
+
+
+58 
+_STRUCT_X86_EXCEPTION_STATE32
+ 
+	ges
+;
+
+59 
+_STRUCT_X86_THREAD_STATE32
+ 
+	gss
+;
+
+60 
+_STRUCT_X86_FLOAT_STATE32
+ 
+	gfs
+;
+
+65 #i�de�
+_STRUCT_MCONTEXT64
+
+
+66 #i�
+__DARWIN_UNIX03
+
+
+67 

+	#_STRUCT_MCONTEXT64
+ 
+__d�w�_mcڋxt64
+
+
+	)
+
+68 
+	g_STRUCT_MCONTEXT64
+
+
+70 
+_STRUCT_X86_EXCEPTION_STATE64
+ 
+	g__es
+;
+
+71 
+_STRUCT_X86_THREAD_STATE64
+ 
+	g__ss
+;
+
+72 
+_STRUCT_X86_FLOAT_STATE64
+ 
+	g__fs
+;
+
+75 

+	#_STRUCT_MCONTEXT64
+ 
+mcڋxt64
+
+
+	)
+
+76 
+	g_STRUCT_MCONTEXT64
+
+
+78 
+_STRUCT_X86_EXCEPTION_STATE64
+ 
+	ges
+;
+
+79 
+_STRUCT_X86_THREAD_STATE64
+ 
+	gss
+;
+
+80 
+_STRUCT_X86_FLOAT_STATE64
+ 
+	gfs
+;
+
+86 #ifde�
+__�ed_mcڋxt_t
+
+
+87 #unde�
+__�ed_mcڋxt_t
+
+
+88 #i�de�
+_MCONTEXT_T
+
+
+89 

+	#_MCONTEXT_T
+
+
+	)
+
+90 #i�
+def�ed
+(
+__LP64__
+)
+
+91 
+_STRUCT_MCONTEXT64
+ *
+	tmcڋxt_t
+;
+
+92 

+	#_STRUCT_MCONTEXT
+ 
+_STRUCT_MCONTEXT64
+
+
+	)
+
+94 
+_STRUCT_MCONTEXT32
+ *
+	tmcڋxt_t
+;
+
+95 

+	#_STRUCT_MCONTEXT
+ 
+_STRUCT_MCONTEXT32
+
+
+	)
+
+100 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+101 #i�de�
+I386_MCONTEXT_SIZE
+
+
+102 

+	#I386_MCONTEXT_SIZE
+ (
+mcڋxt
+)
+
+	)
+
+	@/usr/include/i386/_types.h
+
+28 #i�def 
+_BSD_I386__TYPES_H_
+
+
+29 

+	#_BSD_I386__TYPES_H_
+
+
+	)
+
+36 #ifde�
+__GNUC__
+
+
+37 
+__sig�d
+ 
+	t__�t8_t
+;
+
+39 
+	t__�t8_t
+;
+
+41 
+	t__u�t8_t
+;
+
+42 
+	t__�t16_t
+;
+
+43 
+	t__u�t16_t
+;
+
+44 
+	t__�t32_t
+;
+
+45 
+	t__u�t32_t
+;
+
+46 
+	t__�t64_t
+;
+
+47 
+	t__u�t64_t
+;
+
+49 
+	t__d�w�_���_t
+;
+
+50 
+	t__d�w�_�tu�l_t
+;
+
+70 
+	t__d�w�_�_ru�_t
+;
+
+77 
+	m__mb��e8
+[128];
+
+78 
+	m_mb��eL
+;
+
+79 } 
+	t__mb��e_t
+;
+
+81 
+__mb��e_t
+ 
+	t__d�w�_mb��e_t
+;
+
+83 #i�
+def�ed
+(
+__GNUC__
+�&& def�ed(
+__PTRDIFF_TYPE__
+)
+
+84 
+__PTRDIFF_TYPE__
+ 
+	t__d�w�_�rdiff_t
+;
+
+86 
+	t__d�w�_�rdiff_t
+;
+
+89 #i�
+def�ed
+(
+__GNUC__
+�&& def�ed(
+__SIZE_TYPE__
+)
+
+90 
+__SIZE_TYPE__
+ 
+	t__d�w�_size_t
+;
+
+92 
+	t__d�w�_size_t
+;
+
+95 #i�(
+__GNUC__
+ > 2)
+
+96 
+__bu�t�_va_li�
+ 
+	t__d�w�_va_li�
+;
+
+98 * 
+	t__d�w�_va_li�
+;
+
+101 #i�
+def�ed
+(
+__GNUC__
+�&& def�ed(
+__WCHAR_TYPE__
+)
+
+102 
+__WCHAR_TYPE__
+ 
+	t__d�w�_wch�_t
+;
+
+104 
+__d�w�_�_ru�_t
+ 
+	t__d�w�_wch�_t
+;
+
+107 
+__d�w�_wch�_t
+ 
+	t__d�w�_ru�_t
+;
+
+109 #i�
+def�ed
+(
+__GNUC__
+�&& def�ed(
+__WINT_TYPE__
+)
+
+110 
+__WINT_TYPE__
+ 
+	t__d�w�_w�t_t
+;
+
+112 
+__d�w�_�_ru�_t
+ 
+	t__d�w�_w�t_t
+;
+
+115 
+	t__d�w�_�ock_t
+;
+
+116 
+__u�t32_t
+ 
+	t__d�w�_sock�n_t
+;
+
+117 
+	t__d�w�_ssize_t
+;
+
+118 
+	t__d�w�_time_t
+;
+
+	@/usr/include/machine/signal.h
+
+28 #i�de�
+_BSD_MACHINE_SIGNAL_H_
+
+
+29 

+	#_BSD_MACHINE_SIGNAL_H_
+
+
+	)
+
+31 #i�
+def�ed
+ (
+__�c__
+�|| def�ed (
+__�c64__
+)
+
+32 
+	~"�c/sig�l.h
+"
+
+33 #�i�
+def�ed
+ (
+__i386__
+�|| def�ed(
+__x86_64__
+)
+
+34 
+	~"i386/sig�l.h
+"
+
+35 #�i�
+def�ed
+ (
+__�m__
+)
+
+36 
+	~"�m/sig�l.h
+"
+
+38 #�r� 
+�ch�e�u�
+ 
+n�
+ 
+su�܋d
+
+
+	@/usr/include/ppc/_limits.h
+
+22 #i�def 
+_PPC__LIMITS_H_
+
+
+23 

+	#_PPC__LIMITS_H_
+
+
+	)
+
+25 

+	#__DARWIN_CLK_TCK
+ 100
+
+	)
+
+	@/usr/include/ppc/_structs.h
+
+29 
+	~<sys/cdefs.h
+>
+
+31 #ifde�
+__�ed_mcڋxt_t
+
+
+32 #i�de�
+__�ed_�ru�_mcڋxt
+
+
+33 

+	#__�ed_�ru�_mcڋxt
+
+
+	)
+
+37 #ifde�
+__�ed_mcڋxt64_t
+
+
+38 #i�de�
+__�ed_�ru�_mcڋxt64
+
+
+39 

+	#__�ed_�ru�_mcڋxt64
+
+
+	)
+
+43 #i�
+def�ed
+(
+__�ed_�ru�_mcڋxt
+�|| def�ed(
+__�ed_�ru�_mcڋxt64
+)
+
+44 
+	~<mach/�c/_�ru�s.h
+>
+
+47 #ifde�
+__�ed_�ru�_mcڋxt
+
+
+48 #unde�
+__�ed_�ru�_mcڋxt
+
+
+49 #i�de�
+_STRUCT_MCONTEXT
+
+
+50 #i�
+__DARWIN_UNIX03
+
+
+51 

+	#_STRUCT_MCONTEXT
+ 
+__d�w�_mcڋxt
+
+
+	)
+
+52 
+	g_STRUCT_MCONTEXT
+
+
+54 
+_STRUCT_PPC_EXCEPTION_STATE
+ 
+	g__es
+;
+
+55 
+_STRUCT_PPC_THREAD_STATE
+ 
+	g__ss
+;
+
+56 
+_STRUCT_PPC_FLOAT_STATE
+ 
+	g__fs
+;
+
+57 
+_STRUCT_PPC_VECTOR_STATE
+ 
+	g__vs
+;
+
+60 

+	#_STRUCT_MCONTEXT
+ 
+mcڋxt
+
+
+	)
+
+61 
+	g_STRUCT_MCONTEXT
+
+
+63 
+_STRUCT_PPC_EXCEPTION_STATE
+ 
+	ges
+;
+
+64 
+_STRUCT_PPC_THREAD_STATE
+ 
+	gss
+;
+
+65 
+_STRUCT_PPC_FLOAT_STATE
+ 
+	gfs
+;
+
+66 
+_STRUCT_PPC_VECTOR_STATE
+ 
+	gvs
+;
+
+72 #ifde�
+__�ed_�ru�_mcڋxt64
+
+
+73 #unde�
+__�ed_�ru�_mcڋxt64
+
+
+74 #i�de�
+_STRUCT_MCONTEXT64
+
+
+75 #i�
+__DARWIN_UNIX03
+
+
+76 

+	#_STRUCT_MCONTEXT64
+ 
+__d�w�_mcڋxt64
+
+
+	)
+
+77 
+	g_STRUCT_MCONTEXT64
+
+
+79 
+_STRUCT_PPC_EXCEPTION_STATE64
+ 
+	g__es
+;
+
+80 
+_STRUCT_PPC_THREAD_STATE64
+ 
+	g__ss
+;
+
+81 
+_STRUCT_PPC_FLOAT_STATE
+ 
+	g__fs
+;
+
+82 
+_STRUCT_PPC_VECTOR_STATE
+ 
+	g__vs
+;
+
+85 

+	#_STRUCT_MCONTEXT64
+ 
+mcڋxt64
+
+
+	)
+
+86 
+	g_STRUCT_MCONTEXT64
+
+
+88 
+_STRUCT_PPC_EXCEPTION_STATE64
+ 
+	ges
+;
+
+89 
+_STRUCT_PPC_THREAD_STATE64
+ 
+	gss
+;
+
+90 
+_STRUCT_PPC_FLOAT_STATE
+ 
+	gfs
+;
+
+91 
+_STRUCT_PPC_VECTOR_STATE
+ 
+	gvs
+;
+
+97 #ifde�
+__�ed_mcڋxt_t
+
+
+98 #unde�
+__�ed_mcڋxt_t
+
+
+99 #i�de�
+_MCONTEXT_T
+
+
+100 

+	#_MCONTEXT_T
+
+
+	)
+
+101 
+_STRUCT_MCONTEXT
+ *
+	tmcڋxt_t
+;
+
+105 #ifde�
+__�ed_mcڋxt64_t
+
+
+106 #unde�
+__�ed_mcڋxt64_t
+
+
+107 #i�de�
+_MCONTEXT64_T
+
+
+108 

+	#_MCONTEXT64_T
+
+
+	)
+
+109 
+_STRUCT_MCONTEXT64
+ *
+	tmcڋxt64_t
+;
+
+113 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+114 #i�de�
+PPC_MCONTEXT_SIZE
+
+
+115 

+	#PPC_MCONTEXT_SIZE
+ (
+PPC_THREAD_STATE_COUNT
+ + 
+PPC_FLOAT_STATE_COUNT
+ + 
+PPC_EXCEPTION_STATE_COUNT
+ + 
+PPC_VECTOR_STATE_COUNT
+�* ()
+
+	)
+
+117 #i�de�
+PPC_MCONTEXT64_SIZE
+
+
+118 

+	#PPC_MCONTEXT64_SIZE
+ (
+PPC_THREAD_STATE64_COUNT
+ + 
+PPC_FLOAT_STATE_COUNT
+ + 
+PPC_EXCEPTION_STATE_COUNT
+ + 
+PPC_VECTOR_STATE_COUNT
+�* ()
+
+	)
+
+126 #ifde�
+__�ed_�ru�_sigcڋxt
+
+
+127 #unde�
+__�ed_�ru�_sigcڋxt
+
+
+128 #i�de�
+_STRUCT_SIGCONTEXT
+
+
+129 #i�
+__DARWIN_UNIX03
+
+
+130 

+	#_STRUCT_SIGCONTEXT
+ 
+__d�w�_sigcڋxt
+
+
+	)
+
+131 
+	g_STRUCT_SIGCONTEXT
+
+
+133 
+	g__sc_ڡack
+;
+
+134 
+	g__sc_mask
+;
+
+135 
+	g__sc_�
+;
+
+136 
+	g__sc_psw
+;
+
+137 
+	g__sc_�
+;
+
+138 *
+	g__sc_�gs
+;
+
+141 

+	#_STRUCT_SIGCONTEXT
+ 
+sigcڋxt
+
+
+	)
+
+142 
+	g_STRUCT_SIGCONTEXT
+
+
+144 
+	gsc_ڡack
+;
+
+145 
+	gsc_mask
+;
+
+146 
+	gsc_�
+;
+
+147 
+	gsc_psw
+;
+
+148 
+	gsc_�
+;
+
+149 *
+	gsc_�gs
+;
+
+162 #ifde�
+__�ed_�ru�_sigcڋxt32
+
+
+163 #unde�
+__�ed_�ru�_sigcڋxt32
+
+
+164 #i�de�
+_STRUCT_SIGCONTEXT32
+
+
+165 #i�
+__DARWIN_UNIX03
+
+
+166 

+	#_STRUCT_SIGCONTEXT32
+ 
+__d�w�_sigcڋxt32
+
+
+	)
+
+167 
+	g_STRUCT_SIGCONTEXT32
+
+
+169 
+	g__sc_ڡack
+;
+
+170 
+	g__sc_mask
+;
+
+171 
+	g__sc_�
+;
+
+172 
+	g__sc_psw
+;
+
+173 
+	g__sc_�
+;
+
+174 *
+	g__sc_�gs
+;
+
+177 

+	#_STRUCT_SIGCONTEXT32
+ 
+sigcڋxt32
+
+
+	)
+
+178 
+	g_STRUCT_SIGCONTEXT32
+
+
+180 
+	gsc_ڡack
+;
+
+181 
+	gsc_mask
+;
+
+182 
+	gsc_�
+;
+
+183 
+	gsc_psw
+;
+
+184 
+	gsc_�
+;
+
+185 *
+	gsc_�gs
+;
+
+191 #ifde�
+__�ed_�ru�_sigcڋxt64
+
+
+192 #unde�
+__�ed_�ru�_sigcڋxt64
+
+
+193 #i�de�
+_STRUCT_SIGCONTEXT64
+
+
+194 #i�
+__DARWIN_UNIX03
+
+
+195 

+	#_STRUCT_SIGCONTEXT64
+ 
+__d�w�_sigcڋxt64
+
+
+	)
+
+196 
+	g_STRUCT_SIGCONTEXT64
+
+
+198 
+	g__sc_ڡack
+;
+
+199 
+	g__sc_mask
+;
+
+200 
+	g__sc_�
+;
+
+201 
+	g__sc_psw
+;
+
+202 
+	g__sc_�
+;
+
+203 *
+	g__sc_�gs
+;
+
+206 

+	#_STRUCT_SIGCONTEXT64
+ 
+sigcڋxt64
+
+
+	)
+
+207 
+	g_STRUCT_SIGCONTEXT64
+
+
+209 
+	gsc_ڡack
+;
+
+210 
+	gsc_mask
+;
+
+211 
+	gsc_�
+;
+
+212 
+	gsc_psw
+;
+
+213 
+	gsc_�
+;
+
+214 *
+	gsc_�gs
+;
+
+	@/usr/include/ppc/_types.h
+
+28 #i�def 
+_BSD_PPC__TYPES_H_
+
+
+29 

+	#_BSD_PPC__TYPES_H_
+
+
+	)
+
+36 #ifde�
+__GNUC__
+
+
+37 
+__sig�d
+ 
+	t__�t8_t
+;
+
+39 
+	t__�t8_t
+;
+
+41 
+	t__u�t8_t
+;
+
+42 
+	t__�t16_t
+;
+
+43 
+	t__u�t16_t
+;
+
+44 
+	t__�t32_t
+;
+
+45 
+	t__u�t32_t
+;
+
+46 
+	t__�t64_t
+;
+
+47 
+	t__u�t64_t
+;
+
+49 
+	t__d�w�_���_t
+;
+
+50 
+	t__d�w�_�tu�l_t
+;
+
+70 
+	t__d�w�_�_ru�_t
+;
+
+77 
+	m__mb��e8
+[128];
+
+78 
+	m_mb��eL
+;
+
+79 } 
+	t__mb��e_t
+;
+
+81 
+__mb��e_t
+ 
+	t__d�w�_mb��e_t
+;
+
+83 #i�
+def�ed
+(
+__GNUC__
+�&& def�ed(
+__PTRDIFF_TYPE__
+)
+
+84 
+__PTRDIFF_TYPE__
+ 
+	t__d�w�_�rdiff_t
+;
+
+86 
+	t__d�w�_�rdiff_t
+;
+
+89 #i�
+def�ed
+(
+__GNUC__
+�&& def�ed(
+__SIZE_TYPE__
+)
+
+90 
+__SIZE_TYPE__
+ 
+	t__d�w�_size_t
+;
+
+92 
+	t__d�w�_size_t
+;
+
+95 #i�(
+__GNUC__
+ > 2)
+
+96 
+__bu�t�_va_li�
+ 
+	t__d�w�_va_li�
+;
+
+98 * 
+	t__d�w�_va_li�
+;
+
+101 #i�
+def�ed
+(
+__GNUC__
+�&& def�ed(
+__WCHAR_TYPE__
+)
+
+102 
+__WCHAR_TYPE__
+ 
+	t__d�w�_wch�_t
+;
+
+104 
+__d�w�_�_ru�_t
+ 
+	t__d�w�_wch�_t
+;
+
+107 
+__d�w�_wch�_t
+ 
+	t__d�w�_ru�_t
+;
+
+109 #i�
+def�ed
+(
+__GNUC__
+�&& def�ed(
+__WINT_TYPE__
+)
+
+110 
+__WINT_TYPE__
+ 
+	t__d�w�_w�t_t
+;
+
+112 
+__d�w�_�_ru�_t
+ 
+	t__d�w�_w�t_t
+;
+
+115 
+	t__d�w�_�ock_t
+;
+
+116 
+__u�t32_t
+ 
+	t__d�w�_sock�n_t
+;
+
+117 
+	t__d�w�_ssize_t
+;
+
+118 
+	t__d�w�_time_t
+;
+
+	@/usr/include/sys/_endian.h
+
+90 #i�de�
+_SYS__ENDIAN_H_
+
+
+91 

+	#_SYS__ENDIAN_H_
+
+
+	)
+
+93 
+	~<sys/cdefs.h
+>
+
+99 #i�
+def�ed
+(
+l�t
+)
+
+101 
+__BEGIN_DECLS
+
+
+102 
+__u�t16_t
+ 
+�ohs
+(__uint16_t);
+
+103 
+__u�t16_t
+ 
+ht�s
+(__uint16_t);
+
+104 
+__u�t32_t
+ 
+�ohl
+(__uint32_t);
+
+105 
+__u�t32_t
+ 
+ht�l
+(__uint32_t);
+
+106 
+	g__END_DECLS
+
+
+108 #�i�
+__DARWIN_BYTE_ORDER
+ =�
+__DARWIN_BIG_ENDIAN
+
+
+110 

+	#�ohl
+(
+x
+�(x)
+
+	)
+
+111 

+	#�ohs
+(
+x
+�(x)
+
+	)
+
+112 

+	#ht�l
+(
+x
+�(x)
+
+	)
+
+113 

+	#ht�s
+(
+x
+�(x)
+
+	)
+
+115 #i� 
+def�ed
+(
+KERNEL
+�|| (!def�ed(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+))
+
+116 

+	#NTOHL
+(
+x
+�(x)
+
+	)
+
+117 

+	#NTOHS
+(
+x
+�(x)
+
+	)
+
+118 

+	#HTONL
+(
+x
+�(x)
+
+	)
+
+119 

+	#HTONS
+(
+x
+�(x)
+
+	)
+
+124 
+	~<libk�n/_OSBy�Ord�.h
+>
+
+126 

+	#�ohs
+(
+x
+�
+	`__DARWIN_OSSw�I�16
+(x)
+
+	)
+
+127 

+	#ht�s
+(
+x
+�
+	`__DARWIN_OSSw�I�16
+(x)
+
+	)
+
+129 

+	#�ohl
+(
+x
+�
+	`__DARWIN_OSSw�I�32
+(x)
+
+	)
+
+130 

+	#ht�l
+(
+x
+�
+	`__DARWIN_OSSw�I�32
+(x)
+
+	)
+
+132 #if 
+def�ed
+(
+KERNEL
+�|| (!def�ed(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+))
+
+133 

+	#NTOHL
+(
+x
+�(x��
+	`�ohl
+((
+__u�t32_t
+)x)
+
+	)
+
+134 

+	#NTOHS
+(
+x
+�(x��
+	`�ohs
+((
+__u�t16_t
+)x)
+
+	)
+
+135 

+	#HTONL
+(
+x
+�(x��
+	`ht�l
+((
+__u�t32_t
+)x)
+
+	)
+
+136 

+	#HTONS
+(
+x
+�(x��
+	`ht�s
+((
+__u�t16_t
+)x)
+
+	)
+
+	@/usr/include/i386/signal.h
+
+33 #i�def 
+_I386_SIGNAL_H_
+
+
+34 

+	#_I386_SIGNAL_H_
+ 1
+
+	)
+
+36 
+	~<sys/cdefs.h
+>
+
+38 #i�de�
+_ANSI_SOURCE
+
+
+39 
+	tsig_�omic_t
+;
+
+41 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+43 
+	~<sys/���pi�ts.h
+>
+
+45 #ifde�
+__APPLE_API_OBSOLETE
+
+
+54 

+	#__�ed_�ru�_sigcڋxt
+
+
+	)
+
+55 
+	~<i386/_�ru�s.h
+>
+
+	@/usr/include/libkern/_OSByteOrder.h
+
+29 #i�de�
+_OS__OSBYTEORDER_H
+
+
+30 

+	#_OS__OSBYTEORDER_H
+
+
+	)
+
+40 
+	~<sys/_ty�s.h
+>
+
+43 

+	#__DARWIN_OSSw�CڡI�16
+(
+x
+) \
+
+44 ((
+__u�t16_t
+)((((__u�t16_t)(
+x
+) & 0xff00) >> 8) | \
+
+45 (((
+__u�t16_t
+)(
+x
+�& 0x00ff�<< 8)))
+
+	)
+
+47 

+	#__DARWIN_OSSw�CڡI�32
+(
+x
+) \
+
+48 ((
+__u�t32_t
+)((((__u�t32_t)(
+x
+) & 0xff000000) >> 24) | \
+
+49 (((
+__u�t32_t
+)(
+x
+) & 0x00ff0000) >> 8) | \
+
+50 (((
+__u�t32_t
+)(
+x
+) & 0x0000ff00) << 8) | \
+
+51 (((
+__u�t32_t
+)(
+x
+�& 0x000000ff�<< 24)))
+
+	)
+
+53 

+	#__DARWIN_OSSw�CڡI�64
+(
+x
+) \
+
+54 ((
+__u�t64_t
+)((((__u�t64_t)(
+x
+) & 0xff00000000000000ULL) >> 56) | \
+
+55 (((
+__u�t64_t
+)(
+x
+) & 0x00ff000000000000ULL) >> 40) | \
+
+56 (((
+__u�t64_t
+)(
+x
+) & 0x0000ff0000000000ULL) >> 24) | \
+
+57 (((
+__u�t64_t
+)(
+x
+) & 0x000000ff00000000ULL) >> 8) | \
+
+58 (((
+__u�t64_t
+)(
+x
+) & 0x00000000ff000000ULL) << 8) | \
+
+59 (((
+__u�t64_t
+)(
+x
+) & 0x0000000000ff0000ULL) << 24) | \
+
+60 (((
+__u�t64_t
+)(
+x
+) & 0x000000000000ff00ULL) << 40) | \
+
+61 (((
+__u�t64_t
+)(
+x
+�& 0x00000000000000ffULL�<< 56)))
+
+	)
+
+63 #i�
+def�ed
+(
+__GNUC__
+)
+
+65 #i�
+def�ed
+(
+__i386__
+�|| def�ed(
+__x86_64__
+)
+
+66 
+	~<libk�n/i386/_OSBy�Ord�.h
+>
+
+69 #i�
+def�ed
+(
+__�m__
+)
+
+70 
+	~<libk�n/�m/OSBy�Ord�.h
+>
+
+74 

+	#__DARWIN_OSSw�I�16
+(
+x
+) \
+
+75 (
+	`__bu�t�_cڡ�t_p
+(
+x
+�? 
+	`__DARWIN_OSSw�CڡI�16
+(x�: 
+	`_OSSw�I�16
+(x))
+
+	)
+
+77 

+	#__DARWIN_OSSw�I�32
+(
+x
+) \
+
+78 (
+	`__bu�t�_cڡ�t_p
+(
+x
+�? 
+	`__DARWIN_OSSw�CڡI�32
+(x�: 
+	`_OSSw�I�32
+(x))
+
+	)
+
+80 

+	#__DARWIN_OSSw�I�64
+(
+x
+) \
+
+81 (
+	`__bu�t�_cڡ�t_p
+(
+x
+�? 
+	`__DARWIN_OSSw�CڡI�64
+(x�: 
+	`_OSSw�I�64
+(x))
+
+	)
+
+85 #i�
+def�ed
+(
+__i386__
+�|| def�ed(
+__x86_64__
+)
+
+87 #i�!
+def�ed
+(
+__DARWIN_OS_INLINE
+)
+
+88 #i�
+def�ed
+(
+__STDC_VERSION__
+) && __STDC_VERSION__ >= 199901L
+
+89 

+	#__DARWIN_OS_INLINE
+ 
+�l�e
+
+
+	)
+
+90 #�i�
+def�ed
+(
+__MWERKS__
+�|| def�ed(
+__�lu�lus
+)
+
+91 

+	#__DARWIN_OS_INLINE
+ 
+�l�e
+
+
+	)
+
+93 

+	#__DARWIN_OS_INLINE
+ 
+__�l�e__
+
+
+	)
+
+97 
+__DARWIN_OS_INLINE
+
+
+98 
+u�t16_t
+
+
+99 
+	$_OSSw�I�16
+(
+
+100 
+u�t16_t
+ 
+d�a
+
+
+103  
+	`__DARWIN_OSSw�CڡI�16
+(
+d�a
+);
+
+104 
+	}
+}
+
+106 
+__DARWIN_OS_INLINE
+
+
+107 
+u�t32_t
+
+
+108 
+	$_OSSw�I�32
+(
+
+109 
+u�t32_t
+ 
+d�a
+
+
+112  
+	`__DARWIN_OSSw�CڡI�32
+(
+d�a
+);
+
+113 
+	}
+}
+
+115 
+__DARWIN_OS_INLINE
+
+
+116 
+u�t64_t
+
+
+117 
+	$_OSSw�I�64
+(
+
+118 
+u�t64_t
+ 
+d�a
+
+
+121  
+	`__DARWIN_OSSw�CڡI�64
+(
+d�a
+);
+
+122 
+	}
+}
+
+125 

+	#__DARWIN_OSSw�I�16
+(
+x
+�
+	`_OSSw�I�16
+(x)
+
+	)
+
+127 

+	#__DARWIN_OSSw�I�32
+(
+x
+�
+	`_OSSw�I�32
+(x)
+
+	)
+
+129 

+	#__DARWIN_OSSw�I�64
+(
+x
+�
+	`_OSSw�I�64
+(x)
+
+	)
+
+	@/usr/include/mach/i386/_structs.h
+
+32 #i�def 
+_MACH_I386__STRUCTS_H_
+
+
+33 

+	#_MACH_I386__STRUCTS_H_
+
+
+	)
+
+41 #i�
+__DARWIN_UNIX03
+
+
+42 

+	#_STRUCT_X86_THREAD_STATE32
+ 
+__d�w�_i386_th�ad_��e
+
+
+	)
+
+43 
+	g_STRUCT_X86_THREAD_STATE32
+
+
+45 
+	g__�x
+;
+
+46 
+	g__ebx
+;
+
+47 
+	g__ecx
+;
+
+48 
+	g__edx
+;
+
+49 
+	g__edi
+;
+
+50 
+	g__esi
+;
+
+51 
+	g__ebp
+;
+
+52 
+	g__e�
+;
+
+53 
+	g__ss
+;
+
+54 
+	g__e�ags
+;
+
+55 
+	g__e�
+;
+
+56 
+	g__cs
+;
+
+57 
+	g__ds
+;
+
+58 
+	g__es
+;
+
+59 
+	g__fs
+;
+
+60 
+	g__gs
+;
+
+63 

+	#_STRUCT_X86_THREAD_STATE32
+ 
+i386_th�ad_��e
+
+
+	)
+
+64 
+	g_STRUCT_X86_THREAD_STATE32
+
+
+66 
+	g�x
+;
+
+67 
+	gebx
+;
+
+68 
+	gecx
+;
+
+69 
+	gedx
+;
+
+70 
+	gedi
+;
+
+71 
+	gesi
+;
+
+72 
+	gebp
+;
+
+73 
+	ge�
+;
+
+74 
+	gss
+;
+
+75 
+	ge�ags
+;
+
+76 
+	ge�
+;
+
+77 
+	gcs
+;
+
+78 
+	gds
+;
+
+79 
+	ges
+;
+
+80 
+	gfs
+;
+
+81 
+	ggs
+;
+
+87 #i�
+__DARWIN_UNIX03
+
+
+88 

+	#_STRUCT_FP_CONTROL
+ 
+__d�w�_�_cڌ�
+
+
+	)
+
+89 
+	g_STRUCT_FP_CONTROL
+
+
+91 
+	g__�v�id
+ :1,
+
+92 
+	g__d��m
+ :1,
+
+93 
+	g__zdiv
+ :1,
+
+94 
+	g__ovr�
+ :1,
+
+95 
+	g__und�
+ :1,
+
+96 
+	g__�ecis
+ :1,
+
+98 
+	g__pc
+ :2,
+
+99 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+100 

+	#FP_PREC_24B
+ 0
+
+	)
+
+101 

+	#FP_PREC_53B
+ 2
+
+	)
+
+102 

+	#FP_PREC_64B
+ 3
+
+	)
+
+104 
+	g__rc
+ :2,
+
+105 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+106 

+	#FP_RND_NEAR
+ 0
+
+	)
+
+107 

+	#FP_RND_DOWN
+ 1
+
+	)
+
+108 

+	#FP_RND_UP
+ 2
+
+	)
+
+109 

+	#FP_CHOP
+ 3
+
+	)
+
+114 
+_STRUCT_FP_CONTROL
+ 
+	t__d�w�_�_cڌ�_t
+;
+
+116 

+	#_STRUCT_FP_CONTROL
+ 
+�_cڌ�
+
+
+	)
+
+117 
+	g_STRUCT_FP_CONTROL
+
+
+119 
+	g�v�id
+ :1,
+
+120 
+	gd��m
+ :1,
+
+121 
+	gzdiv
+ :1,
+
+122 
+	govr�
+ :1,
+
+123 
+	gund�
+ :1,
+
+124 
+	g�ecis
+ :1,
+
+126 
+	gpc
+ :2,
+
+127 

+	#FP_PREC_24B
+ 0
+
+	)
+
+128 

+	#FP_PREC_53B
+ 2
+
+	)
+
+129 

+	#FP_PREC_64B
+ 3
+
+	)
+
+130 
+	grc
+ :2,
+
+131 

+	#FP_RND_NEAR
+ 0
+
+	)
+
+132 

+	#FP_RND_DOWN
+ 1
+
+	)
+
+133 

+	#FP_RND_UP
+ 2
+
+	)
+
+134 

+	#FP_CHOP
+ 3
+
+	)
+
+138 
+_STRUCT_FP_CONTROL
+ 
+	t�_cڌ�_t
+;
+
+145 #i�
+__DARWIN_UNIX03
+
+
+146 

+	#_STRUCT_FP_STATUS
+ 
+__d�w�_�_��us
+
+
+	)
+
+147 
+	g_STRUCT_FP_STATUS
+
+
+149 
+	g__�v�id
+ :1,
+
+150 
+	g__d��m
+ :1,
+
+151 
+	g__zdiv
+ :1,
+
+152 
+	g__ovr�
+ :1,
+
+153 
+	g__und�
+ :1,
+
+154 
+	g__�ecis
+ :1,
+
+155 
+	g__�k�t
+ :1,
+
+156 
+	g__�rsumm
+ :1,
+
+157 
+	g__c0
+ :1,
+
+158 
+	g__c1
+ :1,
+
+159 
+	g__c2
+ :1,
+
+160 
+	g__tos
+ :3,
+
+161 
+	g__c3
+ :1,
+
+162 
+	g__busy
+ :1;
+
+164 
+_STRUCT_FP_STATUS
+ 
+	t__d�w�_�_��us_t
+;
+
+166 

+	#_STRUCT_FP_STATUS
+ 
+�_��us
+
+
+	)
+
+167 
+	g_STRUCT_FP_STATUS
+
+
+169 
+	g�v�id
+ :1,
+
+170 
+	gd��m
+ :1,
+
+171 
+	gzdiv
+ :1,
+
+172 
+	govr�
+ :1,
+
+173 
+	gund�
+ :1,
+
+174 
+	g�ecis
+ :1,
+
+175 
+	g�k�t
+ :1,
+
+176 
+	g�rsumm
+ :1,
+
+177 
+	gc0
+ :1,
+
+178 
+	gc1
+ :1,
+
+179 
+	gc2
+ :1,
+
+180 
+	gtos
+ :3,
+
+181 
+	gc3
+ :1,
+
+182 
+	gbusy
+ :1;
+
+184 
+_STRUCT_FP_STATUS
+ 
+	t�_��us_t
+;
+
+189 #i�
+__DARWIN_UNIX03
+
+
+190 

+	#_STRUCT_MMST_REG
+ 
+__d�w�_mm�_�g
+
+
+	)
+
+191 
+	g_STRUCT_MMST_REG
+
+
+193 
+	g__mm�_�g
+[10];
+
+194 
+	g__mm�_r�v
+[6];
+
+197 

+	#_STRUCT_MMST_REG
+ 
+mm�_�g
+
+
+	)
+
+198 
+	g_STRUCT_MMST_REG
+
+
+200 
+	gmm�_�g
+[10];
+
+201 
+	gmm�_r�v
+[6];
+
+208 #i�
+__DARWIN_UNIX03
+
+
+209 

+	#_STRUCT_XMM_REG
+ 
+__d�w�_xmm_�g
+
+
+	)
+
+210 
+	g_STRUCT_XMM_REG
+
+
+212 
+	g__xmm_�g
+[16];
+
+215 

+	#_STRUCT_XMM_REG
+ 
+xmm_�g
+
+
+	)
+
+216 
+	g_STRUCT_XMM_REG
+
+
+218 
+	gxmm_�g
+[16];
+
+226 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+227 

+	#FP_STATE_BYTES
+ 512
+
+	)
+
+230 #i�
+__DARWIN_UNIX03
+
+
+231 

+	#_STRUCT_X86_FLOAT_STATE32
+ 
+__d�w�_i386_��t_��e
+
+
+	)
+
+232 
+	g_STRUCT_X86_FLOAT_STATE32
+
+
+234 
+	g__�u_��rved
+[2];
+
+235 
+_STRUCT_FP_CONTROL
+ 
+	g__�u_fcw
+;
+
+236 
+_STRUCT_FP_STATUS
+ 
+	g__�u_fsw
+;
+
+237 
+__u�t8_t
+ 
+	g__�u_�w
+;
+
+238 
+__u�t8_t
+ 
+	g__�u_r�v1
+;
+
+239 
+__u�t16_t
+ 
+	g__�u_f�
+;
+
+240 
+__u�t32_t
+ 
+	g__�u_�
+;
+
+241 
+__u�t16_t
+ 
+	g__�u_cs
+;
+
+242 
+__u�t16_t
+ 
+	g__�u_r�v2
+;
+
+243 
+__u�t32_t
+ 
+	g__�u_dp
+;
+
+244 
+__u�t16_t
+ 
+	g__�u_ds
+;
+
+245 
+__u�t16_t
+ 
+	g__�u_r�v3
+;
+
+246 
+__u�t32_t
+ 
+	g__�u_mxc�
+;
+
+247 
+__u�t32_t
+ 
+	g__�u_mxc�mask
+;
+
+248 
+_STRUCT_MMST_REG
+ 
+	g__�u_�mm0
+;
+
+249 
+_STRUCT_MMST_REG
+ 
+	g__�u_�mm1
+;
+
+250 
+_STRUCT_MMST_REG
+ 
+	g__�u_�mm2
+;
+
+251 
+_STRUCT_MMST_REG
+ 
+	g__�u_�mm3
+;
+
+252 
+_STRUCT_MMST_REG
+ 
+	g__�u_�mm4
+;
+
+253 
+_STRUCT_MMST_REG
+ 
+	g__�u_�mm5
+;
+
+254 
+_STRUCT_MMST_REG
+ 
+	g__�u_�mm6
+;
+
+255 
+_STRUCT_MMST_REG
+ 
+	g__�u_�mm7
+;
+
+256 
+_STRUCT_XMM_REG
+ 
+	g__�u_xmm0
+;
+
+257 
+_STRUCT_XMM_REG
+ 
+	g__�u_xmm1
+;
+
+258 
+_STRUCT_XMM_REG
+ 
+	g__�u_xmm2
+;
+
+259 
+_STRUCT_XMM_REG
+ 
+	g__�u_xmm3
+;
+
+260 
+_STRUCT_XMM_REG
+ 
+	g__�u_xmm4
+;
+
+261 
+_STRUCT_XMM_REG
+ 
+	g__�u_xmm5
+;
+
+262 
+_STRUCT_XMM_REG
+ 
+	g__�u_xmm6
+;
+
+263 
+_STRUCT_XMM_REG
+ 
+	g__�u_xmm7
+;
+
+264 
+	g__�u_r�v4
+[14*16];
+
+265 
+	g__�u_��rved1
+;
+
+268 

+	#_STRUCT_X86_FLOAT_STATE32
+ 
+i386_��t_��e
+
+
+	)
+
+269 
+	g_STRUCT_X86_FLOAT_STATE32
+
+
+271 
+	g�u_��rved
+[2];
+
+272 
+_STRUCT_FP_CONTROL
+ 
+	g�u_fcw
+;
+
+273 
+_STRUCT_FP_STATUS
+ 
+	g�u_fsw
+;
+
+274 
+__u�t8_t
+ 
+	g�u_�w
+;
+
+275 
+__u�t8_t
+ 
+	g�u_r�v1
+;
+
+276 
+__u�t16_t
+ 
+	g�u_f�
+;
+
+277 
+__u�t32_t
+ 
+	g�u_�
+;
+
+278 
+__u�t16_t
+ 
+	g�u_cs
+;
+
+279 
+__u�t16_t
+ 
+	g�u_r�v2
+;
+
+280 
+__u�t32_t
+ 
+	g�u_dp
+;
+
+281 
+__u�t16_t
+ 
+	g�u_ds
+;
+
+282 
+__u�t16_t
+ 
+	g�u_r�v3
+;
+
+283 
+__u�t32_t
+ 
+	g�u_mxc�
+;
+
+284 
+__u�t32_t
+ 
+	g�u_mxc�mask
+;
+
+285 
+_STRUCT_MMST_REG
+ 
+	g�u_�mm0
+;
+
+286 
+_STRUCT_MMST_REG
+ 
+	g�u_�mm1
+;
+
+287 
+_STRUCT_MMST_REG
+ 
+	g�u_�mm2
+;
+
+288 
+_STRUCT_MMST_REG
+ 
+	g�u_�mm3
+;
+
+289 
+_STRUCT_MMST_REG
+ 
+	g�u_�mm4
+;
+
+290 
+_STRUCT_MMST_REG
+ 
+	g�u_�mm5
+;
+
+291 
+_STRUCT_MMST_REG
+ 
+	g�u_�mm6
+;
+
+292 
+_STRUCT_MMST_REG
+ 
+	g�u_�mm7
+;
+
+293 
+_STRUCT_XMM_REG
+ 
+	g�u_xmm0
+;
+
+294 
+_STRUCT_XMM_REG
+ 
+	g�u_xmm1
+;
+
+295 
+_STRUCT_XMM_REG
+ 
+	g�u_xmm2
+;
+
+296 
+_STRUCT_XMM_REG
+ 
+	g�u_xmm3
+;
+
+297 
+_STRUCT_XMM_REG
+ 
+	g�u_xmm4
+;
+
+298 
+_STRUCT_XMM_REG
+ 
+	g�u_xmm5
+;
+
+299 
+_STRUCT_XMM_REG
+ 
+	g�u_xmm6
+;
+
+300 
+_STRUCT_XMM_REG
+ 
+	g�u_xmm7
+;
+
+301 
+	g�u_r�v4
+[14*16];
+
+302 
+	g�u_��rved1
+;
+
+306 #i�
+__DARWIN_UNIX03
+
+
+307 

+	#_STRUCT_X86_EXCEPTION_STATE32
+ 
+__d�w�_i386_ex��i�_��e
+
+
+	)
+
+308 
+	g_STRUCT_X86_EXCEPTION_STATE32
+
+
+310 
+	g__��no
+;
+
+311 
+	g__�r
+;
+
+312 
+	g__�u�vaddr
+;
+
+315 

+	#_STRUCT_X86_EXCEPTION_STATE32
+ 
+i386_ex��i�_��e
+
+
+	)
+
+316 
+	g_STRUCT_X86_EXCEPTION_STATE32
+
+
+318 
+	g��no
+;
+
+319 
+	g�r
+;
+
+320 
+	g�u�vaddr
+;
+
+324 #i�
+__DARWIN_UNIX03
+
+
+325 

+	#_STRUCT_X86_DEBUG_STATE32
+ 
+__d�w�_x86_debug_��e32
+
+
+	)
+
+326 
+	g_STRUCT_X86_DEBUG_STATE32
+
+
+328 
+	g__dr0
+;
+
+329 
+	g__dr1
+;
+
+330 
+	g__dr2
+;
+
+331 
+	g__dr3
+;
+
+332 
+	g__dr4
+;
+
+333 
+	g__dr5
+;
+
+334 
+	g__dr6
+;
+
+335 
+	g__dr7
+;
+
+338 

+	#_STRUCT_X86_DEBUG_STATE32
+ 
+x86_debug_��e32
+
+
+	)
+
+339 
+	g_STRUCT_X86_DEBUG_STATE32
+
+
+341 
+	gdr0
+;
+
+342 
+	gdr1
+;
+
+343 
+	gdr2
+;
+
+344 
+	gdr3
+;
+
+345 
+	gdr4
+;
+
+346 
+	gdr5
+;
+
+347 
+	gdr6
+;
+
+348 
+	gdr7
+;
+
+356 #i�
+__DARWIN_UNIX03
+
+
+357 

+	#_STRUCT_X86_THREAD_STATE64
+ 
+__d�w�_x86_th�ad_��e64
+
+
+	)
+
+358 
+	g_STRUCT_X86_THREAD_STATE64
+
+
+360 
+__u�t64_t
+ 
+	g__�x
+;
+
+361 
+__u�t64_t
+ 
+	g__rbx
+;
+
+362 
+__u�t64_t
+ 
+	g__rcx
+;
+
+363 
+__u�t64_t
+ 
+	g__rdx
+;
+
+364 
+__u�t64_t
+ 
+	g__rdi
+;
+
+365 
+__u�t64_t
+ 
+	g__rsi
+;
+
+366 
+__u�t64_t
+ 
+	g__rbp
+;
+
+367 
+__u�t64_t
+ 
+	g__r�
+;
+
+368 
+__u�t64_t
+ 
+	g__r8
+;
+
+369 
+__u�t64_t
+ 
+	g__r9
+;
+
+370 
+__u�t64_t
+ 
+	g__r10
+;
+
+371 
+__u�t64_t
+ 
+	g__r11
+;
+
+372 
+__u�t64_t
+ 
+	g__r12
+;
+
+373 
+__u�t64_t
+ 
+	g__r13
+;
+
+374 
+__u�t64_t
+ 
+	g__r14
+;
+
+375 
+__u�t64_t
+ 
+	g__r15
+;
+
+376 
+__u�t64_t
+ 
+	g__r�
+;
+
+377 
+__u�t64_t
+ 
+	g__r�ags
+;
+
+378 
+__u�t64_t
+ 
+	g__cs
+;
+
+379 
+__u�t64_t
+ 
+	g__fs
+;
+
+380 
+__u�t64_t
+ 
+	g__gs
+;
+
+383 

+	#_STRUCT_X86_THREAD_STATE64
+ 
+x86_th�ad_��e64
+
+
+	)
+
+384 
+	g_STRUCT_X86_THREAD_STATE64
+
+
+386 
+__u�t64_t
+ 
+	g�x
+;
+
+387 
+__u�t64_t
+ 
+	grbx
+;
+
+388 
+__u�t64_t
+ 
+	grcx
+;
+
+389 
+__u�t64_t
+ 
+	grdx
+;
+
+390 
+__u�t64_t
+ 
+	grdi
+;
+
+391 
+__u�t64_t
+ 
+	grsi
+;
+
+392 
+__u�t64_t
+ 
+	grbp
+;
+
+393 
+__u�t64_t
+ 
+	gr�
+;
+
+394 
+__u�t64_t
+ 
+	gr8
+;
+
+395 
+__u�t64_t
+ 
+	gr9
+;
+
+396 
+__u�t64_t
+ 
+	gr10
+;
+
+397 
+__u�t64_t
+ 
+	gr11
+;
+
+398 
+__u�t64_t
+ 
+	gr12
+;
+
+399 
+__u�t64_t
+ 
+	gr13
+;
+
+400 
+__u�t64_t
+ 
+	gr14
+;
+
+401 
+__u�t64_t
+ 
+	gr15
+;
+
+402 
+__u�t64_t
+ 
+	gr�
+;
+
+403 
+__u�t64_t
+ 
+	gr�ags
+;
+
+404 
+__u�t64_t
+ 
+	gcs
+;
+
+405 
+__u�t64_t
+ 
+	gfs
+;
+
+406 
+__u�t64_t
+ 
+	ggs
+;
+
+411 #i�
+__DARWIN_UNIX03
+
+
+412 

+	#_STRUCT_X86_FLOAT_STATE64
+ 
+__d�w�_x86_��t_��e64
+
+
+	)
+
+413 
+	g_STRUCT_X86_FLOAT_STATE64
+
+
+415 
+	g__�u_��rved
+[2];
+
+416 
+_STRUCT_FP_CONTROL
+ 
+	g__�u_fcw
+;
+
+417 
+_STRUCT_FP_STATUS
+ 
+	g__�u_fsw
+;
+
+418 
+__u�t8_t
+ 
+	g__�u_�w
+;
+
+419 
+__u�t8_t
+ 
+	g__�u_r�v1
+;
+
+420 
+__u�t16_t
+ 
+	g__�u_f�
+;
+
+423 
+__u�t32_t
+ 
+	g__�u_�
+;
+
+424 
+__u�t16_t
+ 
+	g__�u_cs
+;
+
+426 
+__u�t16_t
+ 
+	g__�u_r�v2
+;
+
+429 
+__u�t32_t
+ 
+	g__�u_dp
+;
+
+430 
+__u�t16_t
+ 
+	g__�u_ds
+;
+
+432 
+__u�t16_t
+ 
+	g__�u_r�v3
+;
+
+433 
+__u�t32_t
+ 
+	g__�u_mxc�
+;
+
+434 
+__u�t32_t
+ 
+	g__�u_mxc�mask
+;
+
+435 
+_STRUCT_MMST_REG
+ 
+	g__�u_�mm0
+;
+
+436 
+_STRUCT_MMST_REG
+ 
+	g__�u_�mm1
+;
+
+437 
+_STRUCT_MMST_REG
+ 
+	g__�u_�mm2
+;
+
+438 
+_STRUCT_MMST_REG
+ 
+	g__�u_�mm3
+;
+
+439 
+_STRUCT_MMST_REG
+ 
+	g__�u_�mm4
+;
+
+440 
+_STRUCT_MMST_REG
+ 
+	g__�u_�mm5
+;
+
+441 
+_STRUCT_MMST_REG
+ 
+	g__�u_�mm6
+;
+
+442 
+_STRUCT_MMST_REG
+ 
+	g__�u_�mm7
+;
+
+443 
+_STRUCT_XMM_REG
+ 
+	g__�u_xmm0
+;
+
+444 
+_STRUCT_XMM_REG
+ 
+	g__�u_xmm1
+;
+
+445 
+_STRUCT_XMM_REG
+ 
+	g__�u_xmm2
+;
+
+446 
+_STRUCT_XMM_REG
+ 
+	g__�u_xmm3
+;
+
+447 
+_STRUCT_XMM_REG
+ 
+	g__�u_xmm4
+;
+
+448 
+_STRUCT_XMM_REG
+ 
+	g__�u_xmm5
+;
+
+449 
+_STRUCT_XMM_REG
+ 
+	g__�u_xmm6
+;
+
+450 
+_STRUCT_XMM_REG
+ 
+	g__�u_xmm7
+;
+
+451 
+_STRUCT_XMM_REG
+ 
+	g__�u_xmm8
+;
+
+452 
+_STRUCT_XMM_REG
+ 
+	g__�u_xmm9
+;
+
+453 
+_STRUCT_XMM_REG
+ 
+	g__�u_xmm10
+;
+
+454 
+_STRUCT_XMM_REG
+ 
+	g__�u_xmm11
+;
+
+455 
+_STRUCT_XMM_REG
+ 
+	g__�u_xmm12
+;
+
+456 
+_STRUCT_XMM_REG
+ 
+	g__�u_xmm13
+;
+
+457 
+_STRUCT_XMM_REG
+ 
+	g__�u_xmm14
+;
+
+458 
+_STRUCT_XMM_REG
+ 
+	g__�u_xmm15
+;
+
+459 
+	g__�u_r�v4
+[6*16];
+
+460 
+	g__�u_��rved1
+;
+
+463 

+	#_STRUCT_X86_FLOAT_STATE64
+ 
+x86_��t_��e64
+
+
+	)
+
+464 
+	g_STRUCT_X86_FLOAT_STATE64
+
+
+466 
+	g�u_��rved
+[2];
+
+467 
+_STRUCT_FP_CONTROL
+ 
+	g�u_fcw
+;
+
+468 
+_STRUCT_FP_STATUS
+ 
+	g�u_fsw
+;
+
+469 
+__u�t8_t
+ 
+	g�u_�w
+;
+
+470 
+__u�t8_t
+ 
+	g�u_r�v1
+;
+
+471 
+__u�t16_t
+ 
+	g�u_f�
+;
+
+474 
+__u�t32_t
+ 
+	g�u_�
+;
+
+475 
+__u�t16_t
+ 
+	g�u_cs
+;
+
+477 
+__u�t16_t
+ 
+	g�u_r�v2
+;
+
+480 
+__u�t32_t
+ 
+	g�u_dp
+;
+
+481 
+__u�t16_t
+ 
+	g�u_ds
+;
+
+483 
+__u�t16_t
+ 
+	g�u_r�v3
+;
+
+484 
+__u�t32_t
+ 
+	g�u_mxc�
+;
+
+485 
+__u�t32_t
+ 
+	g�u_mxc�mask
+;
+
+486 
+_STRUCT_MMST_REG
+ 
+	g�u_�mm0
+;
+
+487 
+_STRUCT_MMST_REG
+ 
+	g�u_�mm1
+;
+
+488 
+_STRUCT_MMST_REG
+ 
+	g�u_�mm2
+;
+
+489 
+_STRUCT_MMST_REG
+ 
+	g�u_�mm3
+;
+
+490 
+_STRUCT_MMST_REG
+ 
+	g�u_�mm4
+;
+
+491 
+_STRUCT_MMST_REG
+ 
+	g�u_�mm5
+;
+
+492 
+_STRUCT_MMST_REG
+ 
+	g�u_�mm6
+;
+
+493 
+_STRUCT_MMST_REG
+ 
+	g�u_�mm7
+;
+
+494 
+_STRUCT_XMM_REG
+ 
+	g�u_xmm0
+;
+
+495 
+_STRUCT_XMM_REG
+ 
+	g�u_xmm1
+;
+
+496 
+_STRUCT_XMM_REG
+ 
+	g�u_xmm2
+;
+
+497 
+_STRUCT_XMM_REG
+ 
+	g�u_xmm3
+;
+
+498 
+_STRUCT_XMM_REG
+ 
+	g�u_xmm4
+;
+
+499 
+_STRUCT_XMM_REG
+ 
+	g�u_xmm5
+;
+
+500 
+_STRUCT_XMM_REG
+ 
+	g�u_xmm6
+;
+
+501 
+_STRUCT_XMM_REG
+ 
+	g�u_xmm7
+;
+
+502 
+_STRUCT_XMM_REG
+ 
+	g�u_xmm8
+;
+
+503 
+_STRUCT_XMM_REG
+ 
+	g�u_xmm9
+;
+
+504 
+_STRUCT_XMM_REG
+ 
+	g�u_xmm10
+;
+
+505 
+_STRUCT_XMM_REG
+ 
+	g�u_xmm11
+;
+
+506 
+_STRUCT_XMM_REG
+ 
+	g�u_xmm12
+;
+
+507 
+_STRUCT_XMM_REG
+ 
+	g�u_xmm13
+;
+
+508 
+_STRUCT_XMM_REG
+ 
+	g�u_xmm14
+;
+
+509 
+_STRUCT_XMM_REG
+ 
+	g�u_xmm15
+;
+
+510 
+	g�u_r�v4
+[6*16];
+
+511 
+	g�u_��rved1
+;
+
+515 #i�
+__DARWIN_UNIX03
+
+
+516 

+	#_STRUCT_X86_EXCEPTION_STATE64
+ 
+__d�w�_x86_ex��i�_��e64
+
+
+	)
+
+517 
+	g_STRUCT_X86_EXCEPTION_STATE64
+
+
+519 
+	g__��no
+;
+
+520 
+	g__�r
+;
+
+521 
+__u�t64_t
+ 
+	g__�u�vaddr
+;
+
+524 

+	#_STRUCT_X86_EXCEPTION_STATE64
+ 
+x86_ex��i�_��e64
+
+
+	)
+
+525 
+	g_STRUCT_X86_EXCEPTION_STATE64
+
+
+527 
+	g��no
+;
+
+528 
+	g�r
+;
+
+529 
+__u�t64_t
+ 
+	g�u�vaddr
+;
+
+533 #i�
+__DARWIN_UNIX03
+
+
+534 

+	#_STRUCT_X86_DEBUG_STATE64
+ 
+__d�w�_x86_debug_��e64
+
+
+	)
+
+535 
+	g_STRUCT_X86_DEBUG_STATE64
+
+
+537 
+__u�t64_t
+ 
+	g__dr0
+;
+
+538 
+__u�t64_t
+ 
+	g__dr1
+;
+
+539 
+__u�t64_t
+ 
+	g__dr2
+;
+
+540 
+__u�t64_t
+ 
+	g__dr3
+;
+
+541 
+__u�t64_t
+ 
+	g__dr4
+;
+
+542 
+__u�t64_t
+ 
+	g__dr5
+;
+
+543 
+__u�t64_t
+ 
+	g__dr6
+;
+
+544 
+__u�t64_t
+ 
+	g__dr7
+;
+
+547 

+	#_STRUCT_X86_DEBUG_STATE64
+ 
+x86_debug_��e64
+
+
+	)
+
+548 
+	g_STRUCT_X86_DEBUG_STATE64
+
+
+550 
+__u�t64_t
+ 
+	gdr0
+;
+
+551 
+__u�t64_t
+ 
+	gdr1
+;
+
+552 
+__u�t64_t
+ 
+	gdr2
+;
+
+553 
+__u�t64_t
+ 
+	gdr3
+;
+
+554 
+__u�t64_t
+ 
+	gdr4
+;
+
+555 
+__u�t64_t
+ 
+	gdr5
+;
+
+556 
+__u�t64_t
+ 
+	gdr6
+;
+
+557 
+__u�t64_t
+ 
+	gdr7
+;
+
+	@/usr/include/mach/ppc/_structs.h
+
+32 #i�def 
+_MACH_PPC__STRUCTS_H_
+
+
+33 

+	#_MACH_PPC__STRUCTS_H_
+
+
+	)
+
+35 
+	~<sys/cdefs.h
+>
+
+43 #i�
+__DARWIN_UNIX03
+
+
+44 

+	#_STRUCT_PPC_THREAD_STATE
+ 
+__d�w�_�c_th�ad_��e
+
+
+	)
+
+45 
+	g_STRUCT_PPC_THREAD_STATE
+
+
+47 
+	g__�r0
+;
+
+48 
+	g__�r1
+;
+
+49 
+	g__r0
+;
+
+50 
+	g__r1
+;
+
+51 
+	g__r2
+;
+
+52 
+	g__r3
+;
+
+53 
+	g__r4
+;
+
+54 
+	g__r5
+;
+
+55 
+	g__r6
+;
+
+56 
+	g__r7
+;
+
+57 
+	g__r8
+;
+
+58 
+	g__r9
+;
+
+59 
+	g__r10
+;
+
+60 
+	g__r11
+;
+
+61 
+	g__r12
+;
+
+62 
+	g__r13
+;
+
+63 
+	g__r14
+;
+
+64 
+	g__r15
+;
+
+65 
+	g__r16
+;
+
+66 
+	g__r17
+;
+
+67 
+	g__r18
+;
+
+68 
+	g__r19
+;
+
+69 
+	g__r20
+;
+
+70 
+	g__r21
+;
+
+71 
+	g__r22
+;
+
+72 
+	g__r23
+;
+
+73 
+	g__r24
+;
+
+74 
+	g__r25
+;
+
+75 
+	g__r26
+;
+
+76 
+	g__r27
+;
+
+77 
+	g__r28
+;
+
+78 
+	g__r29
+;
+
+79 
+	g__r30
+;
+
+80 
+	g__r31
+;
+
+82 
+	g__�
+;
+
+83 
+	g__x�
+;
+
+84 
+	g__�
+;
+
+85 
+	g__�r
+;
+
+86 
+	g__mq
+;
+
+88 
+	g__vr�ve
+;
+
+91 

+	#_STRUCT_PPC_THREAD_STATE
+ 
+�c_th�ad_��e
+
+
+	)
+
+92 
+	g_STRUCT_PPC_THREAD_STATE
+
+
+94 
+	g�r0
+;
+
+95 
+	g�r1
+;
+
+96 
+	gr0
+;
+
+97 
+	gr1
+;
+
+98 
+	gr2
+;
+
+99 
+	gr3
+;
+
+100 
+	gr4
+;
+
+101 
+	gr5
+;
+
+102 
+	gr6
+;
+
+103 
+	gr7
+;
+
+104 
+	gr8
+;
+
+105 
+	gr9
+;
+
+106 
+	gr10
+;
+
+107 
+	gr11
+;
+
+108 
+	gr12
+;
+
+109 
+	gr13
+;
+
+110 
+	gr14
+;
+
+111 
+	gr15
+;
+
+112 
+	gr16
+;
+
+113 
+	gr17
+;
+
+114 
+	gr18
+;
+
+115 
+	gr19
+;
+
+116 
+	gr20
+;
+
+117 
+	gr21
+;
+
+118 
+	gr22
+;
+
+119 
+	gr23
+;
+
+120 
+	gr24
+;
+
+121 
+	gr25
+;
+
+122 
+	gr26
+;
+
+123 
+	gr27
+;
+
+124 
+	gr28
+;
+
+125 
+	gr29
+;
+
+126 
+	gr30
+;
+
+127 
+	gr31
+;
+
+129 
+	g�
+;
+
+130 
+	gx�
+;
+
+131 
+	g�
+;
+
+132 
+	g�r
+;
+
+133 
+	gmq
+;
+
+135 
+	gvr�ve
+;
+
+139 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+141 #�agm�
+�ck
+(4)
+
+143 #i�
+__DARWIN_UNIX03
+
+
+144 

+	#_STRUCT_PPC_THREAD_STATE64
+ 
+__d�w�_�c_th�ad_��e64
+
+
+	)
+
+145 
+	g_STRUCT_PPC_THREAD_STATE64
+
+
+147 
+	g__�r0
+;
+
+148 
+	g__�r1
+;
+
+149 
+	g__r0
+;
+
+150 
+	g__r1
+;
+
+151 
+	g__r2
+;
+
+152 
+	g__r3
+;
+
+153 
+	g__r4
+;
+
+154 
+	g__r5
+;
+
+155 
+	g__r6
+;
+
+156 
+	g__r7
+;
+
+157 
+	g__r8
+;
+
+158 
+	g__r9
+;
+
+159 
+	g__r10
+;
+
+160 
+	g__r11
+;
+
+161 
+	g__r12
+;
+
+162 
+	g__r13
+;
+
+163 
+	g__r14
+;
+
+164 
+	g__r15
+;
+
+165 
+	g__r16
+;
+
+166 
+	g__r17
+;
+
+167 
+	g__r18
+;
+
+168 
+	g__r19
+;
+
+169 
+	g__r20
+;
+
+170 
+	g__r21
+;
+
+171 
+	g__r22
+;
+
+172 
+	g__r23
+;
+
+173 
+	g__r24
+;
+
+174 
+	g__r25
+;
+
+175 
+	g__r26
+;
+
+176 
+	g__r27
+;
+
+177 
+	g__r28
+;
+
+178 
+	g__r29
+;
+
+179 
+	g__r30
+;
+
+180 
+	g__r31
+;
+
+182 
+	g__�
+;
+
+183 
+	g__x�
+;
+
+184 
+	g__�
+;
+
+185 
+	g__�r
+;
+
+187 
+	g__vr�ve
+;
+
+190 

+	#_STRUCT_PPC_THREAD_STATE64
+ 
+�c_th�ad_��e64
+
+
+	)
+
+191 
+	g_STRUCT_PPC_THREAD_STATE64
+
+
+193 
+	g�r0
+;
+
+194 
+	g�r1
+;
+
+195 
+	gr0
+;
+
+196 
+	gr1
+;
+
+197 
+	gr2
+;
+
+198 
+	gr3
+;
+
+199 
+	gr4
+;
+
+200 
+	gr5
+;
+
+201 
+	gr6
+;
+
+202 
+	gr7
+;
+
+203 
+	gr8
+;
+
+204 
+	gr9
+;
+
+205 
+	gr10
+;
+
+206 
+	gr11
+;
+
+207 
+	gr12
+;
+
+208 
+	gr13
+;
+
+209 
+	gr14
+;
+
+210 
+	gr15
+;
+
+211 
+	gr16
+;
+
+212 
+	gr17
+;
+
+213 
+	gr18
+;
+
+214 
+	gr19
+;
+
+215 
+	gr20
+;
+
+216 
+	gr21
+;
+
+217 
+	gr22
+;
+
+218 
+	gr23
+;
+
+219 
+	gr24
+;
+
+220 
+	gr25
+;
+
+221 
+	gr26
+;
+
+222 
+	gr27
+;
+
+223 
+	gr28
+;
+
+224 
+	gr29
+;
+
+225 
+	gr30
+;
+
+226 
+	gr31
+;
+
+228 
+	g�
+;
+
+229 
+	gx�
+;
+
+230 
+	g�
+;
+
+231 
+	g�r
+;
+
+233 
+	gvr�ve
+;
+
+237 #�agm�
+�ck
+()
+
+243 #i�
+__DARWIN_UNIX03
+
+
+244 

+	#_STRUCT_PPC_FLOAT_STATE
+ 
+__d�w�_�c_��t_��e
+
+
+	)
+
+245 
+	g_STRUCT_PPC_FLOAT_STATE
+
+
+247 
+	g__�gs
+[32];
+
+249 
+	g__�s�_�d
+;
+
+250 
+	g__�s�
+;
+
+253 

+	#_STRUCT_PPC_FLOAT_STATE
+ 
+�c_��t_��e
+
+
+	)
+
+254 
+	g_STRUCT_PPC_FLOAT_STATE
+
+
+256 
+	g�gs
+[32];
+
+258 
+	g�s�_�d
+;
+
+259 
+	g�s�
+;
+
+263 #�agm�
+�ck
+(4)
+
+265 #i�
+__DARWIN_UNIX03
+
+
+266 

+	#_STRUCT_PPC_VECTOR_STATE
+ 
+__d�w�_�c_ve��_��e
+
+
+	)
+
+267 
+	g_STRUCT_PPC_VECTOR_STATE
+
+
+269 #i�
+def�ed
+(
+__LP64__
+)
+
+270 
+	g__�ve_vr
+[32][4];
+
+271 
+	g__�ve_vs�
+[4];
+
+273 
+	g__�ve_vr
+[32][4];
+
+274 
+	g__�ve_vs�
+[4];
+
+276 
+	g__�ve_�d5
+[4];
+
+277 
+	g__�ve_vrv�id
+;
+
+278 
+	g__�ve_�d6
+[7];
+
+281 

+	#_STRUCT_PPC_VECTOR_STATE
+ 
+�c_ve��_��e
+
+
+	)
+
+282 
+	g_STRUCT_PPC_VECTOR_STATE
+
+
+284 #i�
+def�ed
+(
+__LP64__
+)
+
+285 
+	g�ve_vr
+[32][4];
+
+286 
+	g�ve_vs�
+[4];
+
+288 
+	g�ve_vr
+[32][4];
+
+289 
+	g�ve_vs�
+[4];
+
+291 
+	g�ve_�d5
+[4];
+
+292 
+	g�ve_vrv�id
+;
+
+293 
+	g�ve_�d6
+[7];
+
+297 #�agm�
+�ck
+()
+
+316 #�agm�
+�ck
+(4)
+
+318 #i�
+__DARWIN_UNIX03
+
+
+319 

+	#_STRUCT_PPC_EXCEPTION_STATE
+ 
+__d�w�_�c_ex��i�_��e
+
+
+	)
+
+320 
+	g_STRUCT_PPC_EXCEPTION_STATE
+
+
+322 #i�
+def�ed
+(
+__LP64__
+)
+
+323 
+	g__d�
+;
+
+324 
+	g__dsi�
+;
+
+325 
+	g__ex��i�
+;
+
+326 
+	g__�d0
+;
+
+327 
+	g__�d1
+[4];
+
+329 
+	g__d�
+;
+
+330 
+	g__dsi�
+;
+
+331 
+	g__ex��i�
+;
+
+332 
+	g__�d0
+;
+
+333 
+	g__�d1
+[4];
+
+337 

+	#_STRUCT_PPC_EXCEPTION_STATE
+ 
+�c_ex��i�_��e
+
+
+	)
+
+338 
+	g_STRUCT_PPC_EXCEPTION_STATE
+
+
+340 #i�
+def�ed
+(
+__LP64__
+)
+
+341 
+	gd�
+;
+
+342 
+	gdsi�
+;
+
+343 
+	gex��i�
+;
+
+344 
+	g�d0
+;
+
+345 
+	g�d1
+[4];
+
+347 
+	gd�
+;
+
+348 
+	gdsi�
+;
+
+349 
+	gex��i�
+;
+
+350 
+	g�d0
+;
+
+351 
+	g�d1
+[4];
+
+356 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+357 #i�
+__DARWIN_UNIX03
+
+
+358 

+	#_STRUCT_PPC_EXCEPTION_STATE64
+ 
+__d�w�_�c_ex��i�_��e64
+
+
+	)
+
+359 
+	g_STRUCT_PPC_EXCEPTION_STATE64
+
+
+361 
+	g__d�
+;
+
+362 #i�
+def�ed
+(
+__LP64__
+)
+
+363 
+	g__dsi�
+;
+
+364 
+	g__ex��i�
+;
+
+365 
+	g__�d1
+[4];
+
+367 
+	g__dsi�
+;
+
+368 
+	g__ex��i�
+;
+
+369 
+	g__�d1
+[4];
+
+373 

+	#_STRUCT_PPC_EXCEPTION_STATE64
+ 
+�c_ex��i�_��e64
+
+
+	)
+
+374 
+	g_STRUCT_PPC_EXCEPTION_STATE64
+
+
+376 
+	gd�
+;
+
+377 #i�
+def�ed
+(
+__LP64__
+)
+
+378 
+	gdsi�
+;
+
+379 
+	gex��i�
+;
+
+380 
+	g�d1
+[4];
+
+382 
+	gdsi�
+;
+
+383 
+	gex��i�
+;
+
+384 
+	g�d1
+[4];
+
+390 #�agm�
+�ck
+()
+
+	@/usr/include/ppc/signal.h
+
+32 #i�def 
+_PPC_SIGNAL_H_
+
+
+33 

+	#_PPC_SIGNAL_H_
+ 1
+
+	)
+
+35 
+	~<sys/cdefs.h
+>
+
+37 #i�de�
+_ANSI_SOURCE
+
+
+39 
+	tsig_�omic_t
+;
+
+41 
+	~<sys/���pi�ts.h
+>
+
+43 #ifde�
+__APPLE_API_OBSOLETE
+
+
+45 #i�!
+def�ed
+(
+_POSIX_C_SOURCE
+�|| def�ed(
+_DARWIN_C_SOURCE
+)
+
+47 

+	#__�ed_�ru�_sigcڋxt
+
+
+	)
+
+48 

+	#__�ed_�ru�_sigcڋxt32
+
+
+	)
+
+49 

+	#__�ed_�ru�_sigcڋxt64
+
+
+	)
+
+50 
+	~<�c/_�ru�s.h
+>
+
+55 

+	#SV_SAVE_REGS
+ 0x1000
+
+	)
+
+69 
+	mREGS_SAVED_NONE
+,
+
+70 
+	mREGS_SAVED_CALLER
+,
+
+73 
+	mREGS_SAVED_ALL
+
+
+74 } 
+	t�gs_�ved_t
+;
+
+	@/usr/include/libkern/i386/_OSByteOrder.h
+
+29 #i�de�
+_OS__OSBYTEORDERI386_H
+
+
+30 

+	#_OS__OSBYTEORDERI386_H
+
+
+	)
+
+32 #i�!
+def�ed
+(
+__DARWIN_OS_INLINE
+)
+
+33 #i�
+def�ed
+(
+__STDC_VERSION__
+) && __STDC_VERSION__ >= 199901L
+
+34 

+	#__DARWIN_OS_INLINE
+ 
+�l�e
+
+
+	)
+
+35 #�i�
+def�ed
+(
+__MWERKS__
+�|| def�ed(
+__�lu�lus
+)
+
+36 

+	#__DARWIN_OS_INLINE
+ 
+�l�e
+
+
+	)
+
+38 

+	#__DARWIN_OS_INLINE
+ 
+__�l�e__
+
+
+	)
+
+44 
+__DARWIN_OS_INLINE
+
+
+45 
+__u�t16_t
+
+
+46 
+	$_OSSw�I�16
+(
+
+47 
+__u�t16_t
+ 
+_d�a
+
+
+50  ((
+_d�a
+ << 8) | (_data >> 8));
+
+51 
+	}
+}
+
+53 
+__DARWIN_OS_INLINE
+
+
+54 
+__u�t32_t
+
+
+55 
+	$_OSSw�I�32
+(
+
+56 
+__u�t32_t
+ 
+_d�a
+
+
+59 
+	`__asm__
+ ("bsw� %0" : "+r" (
+_d�a
+));
+
+60  
+_d�a
+;
+
+61 
+	}
+}
+
+63 #i�
+def�ed
+(
+__i386__
+)
+
+64 
+__DARWIN_OS_INLINE
+
+
+65 
+__u�t64_t
+
+
+66 
+	$_OSSw�I�64
+(
+
+67 
+__u�t64_t
+ 
+_d�a
+
+
+70 
+	`__asm__
+ ("bswap %%eax\n\t"
+
+73 : "+A" (
+_d�a
+));
+
+74  
+_d�a
+;
+
+75 
+	}
+}
+
+76 #�i�
+def�ed
+(
+__x86_64__
+)
+
+77 
+__DARWIN_OS_INLINE
+
+
+78 
+__u�t64_t
+
+
+79 
+	$_OSSw�I�64
+(
+
+80 
+__u�t64_t
+ 
+_d�a
+
+
+83 
+	`__asm__
+ ("bsw� %0" : "+r" (
+_d�a
+));
+
+84  
+_d�a
+;
+
+85 
+	}
+}
+
+87 #�r� 
+Unknown
+ 
+�ch�e�u�
+
+
+	@
+1
+.
+1
+/usr/include
+69
+1617
+debug.h
+filterfs.c
+filterfs.h
+lib.c
+lib.h
+lnode.c
+lnode.h
+ncache.c
+ncache.h
+node.c
+node.h
+options.c
+options.h
+/usr/include/dirent.h
+/usr/include/fcntl.h
+/usr/include/stddef.h
+/usr/include/stdio.h
+/usr/include/stdlib.h
+/usr/include/sys/mman.h
+/usr/include/sys/stat.h
+/usr/include/sys/time.h
+/usr/include/sys/types.h
+/usr/include/unistd.h
+/usr/include/_types.h
+/usr/include/_xlocale.h
+/usr/include/alloca.h
+/usr/include/available.h
+/usr/include/machine/endian.h
+/usr/include/machine/types.h
+/usr/include/secure/_stdio.h
+/usr/include/sys/_select.h
+/usr/include/sys/_structs.h
+/usr/include/sys/_types.h
+/usr/include/sys/appleapiopts.h
+/usr/include/sys/cdefs.h
+/usr/include/sys/dirent.h
+/usr/include/sys/fcntl.h
+/usr/include/sys/select.h
+/usr/include/sys/unistd.h
+/usr/include/sys/wait.h
+/usr/include/time.h
+/usr/include/xlocale/_stdio.h
+/usr/include/xlocale/_stdlib.h
+/usr/include/_structs.h
+/usr/include/i386/endian.h
+/usr/include/i386/types.h
+/usr/include/machine/_limits.h
+/usr/include/machine/_structs.h
+/usr/include/machine/_types.h
+/usr/include/ppc/endian.h
+/usr/include/ppc/types.h
+/usr/include/secure/_common.h
+/usr/include/sys/resource.h
+/usr/include/sys/signal.h
+/usr/include/xlocale/_time.h
+/usr/include/i386/_limits.h
+/usr/include/i386/_structs.h
+/usr/include/i386/_types.h
+/usr/include/machine/signal.h
+/usr/include/ppc/_limits.h
+/usr/include/ppc/_structs.h
+/usr/include/ppc/_types.h
+/usr/include/sys/_endian.h
+/usr/include/i386/signal.h
+/usr/include/libkern/_OSByteOrder.h
+/usr/include/mach/i386/_structs.h
+/usr/include/mach/ppc/_structs.h
+/usr/include/ppc/signal.h
+/usr/include/libkern/i386/_OSByteOrder.h
diff --git a/netfs-sample/debug.h b/netfs-sample/debug.h
new file mode 100644
index 00000000..606d7e79
--- /dev/null
+++ b/netfs-sample/debug.h
@@ -0,0 +1,60 @@
+/*----------------------------------------------------------------------------*/
+/*debug.h*/
+/*----------------------------------------------------------------------------*/
+/*Simple facilities for debugging messages*/
+/*----------------------------------------------------------------------------*/
+/*Based on the code of unionfs translator.*/
+/*----------------------------------------------------------------------------*/
+/*Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
+  Written by Sergiu Ivanov <unlimitedscolobb@gmail.com>.
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or * (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.*/
+/*----------------------------------------------------------------------------*/
+#ifndef __DEBUG_H__
+#define __DEBUG_H__
+
+/*----------------------------------------------------------------------------*/
+#include <stdio.h>
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Macros--------------------------------------------------------------*/
+/*Print debug messages here*/
+#define DEBUG_OUTPUT "/var/tmp/filterfs.dbg"
+/*----------------------------------------------------------------------------*/
+#ifdef DEBUG
+	/*Initializes the log*/
+#	define INIT_LOG() filterfs_dbg = fopen(DEBUG_OUTPUT, "wt")
+	/*Closes the log*/
+# define CLOSE_LOG() fclose(filterfs_dbg)
+	/*Prints a debug message and flushes the debug output*/
+#	define LOG_MSG(fmt, args...) {fprintf(filterfs_dbg, fmt"\n", ##args);\
+		fflush(filterfs_dbg);}
+#else
+	/*Remove requests for debugging output*/
+#	define INIT_LOG()
+#	define CLOSE_LOG()
+#	define LOG_MSG(fmt, args...)
+#endif /*DEBUG*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Global Variables----------------------------------------------------*/
+/*The file to write debugging info to*/
+extern FILE * filterfs_dbg;
+/*----------------------------------------------------------------------------*/
+
+#endif /*__DEBUG_H__*/
diff --git a/netfs-sample/errors b/netfs-sample/errors
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/netfs-sample/errors
diff --git a/netfs-sample/filtered b/netfs-sample/filtered
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/netfs-sample/filtered
diff --git a/netfs-sample/filterfs b/netfs-sample/filterfs
new file mode 100755
index 00000000..012a5b3a
--- /dev/null
+++ b/netfs-sample/filterfs
diff --git a/netfs-sample/filterfs.c b/netfs-sample/filterfs.c
new file mode 100644
index 00000000..d768e18b
--- /dev/null
+++ b/netfs-sample/filterfs.c
@@ -0,0 +1,1236 @@
+/*----------------------------------------------------------------------------*/
+/*filter.c*/
+/*----------------------------------------------------------------------------*/
+/*The filtering translator*/
+/*----------------------------------------------------------------------------*/
+/*Based on the code of unionfs translator.*/
+/*----------------------------------------------------------------------------*/
+/*Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
+  Written by Sergiu Ivanov <unlimitedscolobb@gmail.com>.
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or * (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+#define _GNU_SOURCE 1
+/*----------------------------------------------------------------------------*/
+#include "filterfs.h"
+/*----------------------------------------------------------------------------*/
+#include <error.h>
+#include <argp.h>
+#include <argz.h>
+#include <hurd/netfs.h>
+#include <fcntl.h>
+/*----------------------------------------------------------------------------*/
+#include "debug.h"
+#include "options.h"
+#include "ncache.h"
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Macros--------------------------------------------------------------*/
+/*The state modes use in open*/
+#define OPENONLY_STATE_MODES (O_CREAT | O_EXCL | O_NOLINK | O_NOTRANS \
+			      | O_NONBLOCK)
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Global Variables----------------------------------------------------*/
+/*The name of the server*/
+char * netfs_server_name = "filterfs";
+/*----------------------------------------------------------------------------*/
+/*The version of the server*/
+char * netfs_server_version = "0.0";
+/*----------------------------------------------------------------------------*/
+/*The maximal length of a chain of symbolic links*/
+int netfs_maxsymlinks = 12;
+/*----------------------------------------------------------------------------*/
+/*A port to the underlying node*/
+mach_port_t underlying_node;
+/*----------------------------------------------------------------------------*/
+/*Status information for the underlying node*/
+io_statbuf_t underlying_node_stat;
+/*----------------------------------------------------------------------------*/
+/*Mapped time used for updating node information*/
+volatile struct mapped_time_value * maptime;
+/*----------------------------------------------------------------------------*/
+/*The filesystem ID*/
+pid_t fsid;
+/*----------------------------------------------------------------------------*/
+/*The file to print debug messages to*/
+FILE * filterfs_dbg;
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Functions-----------------------------------------------------------*/
+/*Attempts to create a file named `name` in `dir` for `user` with mode `mode`*/
+error_t
+netfs_attempt_create_file
+(
+ struct iouser * user,
+ struct node * dir,
+ char * name,
+ mode_t mode,
+ struct node ** node
+)
+{
+  LOG_MSG("netfs_attempt_create_file");
+
+  /*Unlock `dir` and say that we can do nothing else here*/
+  mutex_unlock(&dir->lock);
+  return EOPNOTSUPP;
+}/*netfs_attempt_create_file*/
+/*----------------------------------------------------------------------------*/
+/*Return an error if the process of opening a file should not be allowed
+  to complete because of insufficient permissions*/
+error_t
+netfs_check_open_permissions
+(
+ struct iouser * user,
+ struct node * np,
+ int flags,
+ int newnode
+)
+{
+  LOG_MSG("netfs_check_open_permissions: '%s'", np->nn->lnode->name);
+
+  error_t err = 0;
+
+  /*Cheks user's permissions*/
+  if(flags & O_READ)
+    err = fshelp_access(&np->nn_stat, S_IREAD, user);
+  if(!err && (flags & O_WRITE))
+    err = fshelp_access(&np->nn_stat, S_IWRITE, user);
+  if(!err && (flags & O_EXEC))
+    err = fshelp_access(&np->nn_stat, S_IEXEC, user);
+
+  /*Return the result of the check*/
+  return err;
+}/*netfs_check_open_permissions*/
+/*----------------------------------------------------------------------------*/
+/*Attempts an utimes call for the user `cred` on node `node`*/
+error_t
+netfs_attempt_utimes
+(
+ struct iouser * cred,
+ struct node * node,
+ struct timespec * atime,
+ struct timespec * mtime
+)
+{
+  LOG_MSG("netfs_attempt_utimes");
+
+  error_t err = 0;
+
+  /*See what information is to be updated*/
+  int flags = TOUCH_CTIME;
+
+  /*Check if the user is indeed the owner of the node*/
+  err = fshelp_isowner(&node->nn_stat, cred);
+
+  /*If the user is allowed to do utimes*/
+  if(!err)
+    {
+      /*If atime is to be updated*/
+      if(atime)
+	/*update the atime*/
+	node->nn_stat.st_atim = *atime;
+      else
+	/*the current time will be set as the atime*/
+	flags |= TOUCH_ATIME;
+
+      /*If mtime is to be updated*/
+      if(mtime)
+	/*update the mtime*/
+	node->nn_stat.st_mtim = *mtime;
+      else
+	/*the current time will be set as mtime*/
+	flags |= TOUCH_MTIME;
+
+      /*touch the file*/
+      fshelp_touch(&node->nn_stat, flags, maptime);
+    }
+
+  /*Return the result of operations*/
+  return err;
+}/*netfs_attempt_utimes*/
+/*----------------------------------------------------------------------------*/
+/*Returns the valid access types for file `node` and user `cred`*/
+error_t
+netfs_report_access
+(
+ struct iouser * cred,
+ struct node * np,
+ int * types
+)
+{
+  LOG_MSG("netfs_report_access");
+
+  /*No access at first*/
+  *types = 0;
+
+  /*Check the access and set the required bits*/
+  if(fshelp_access(&np->nn_stat, S_IREAD,  cred) == 0)
+    *types |= O_READ;
+  if(fshelp_access(&np->nn_stat, S_IWRITE, cred) == 0)
+    *types |= O_WRITE;
+  if(fshelp_access(&np->nn_stat, S_IEXEC,  cred) == 0)
+    *types |= O_EXEC;
+
+  /*Everything OK*/
+  return 0;
+}/*netfs_report_access*/
+/*----------------------------------------------------------------------------*/
+/*Validates the stat data for the node*/
+error_t
+netfs_validate_stat
+(
+ struct node * np,
+ struct iouser * cred
+)
+{
+  LOG_MSG("netfs_validate_stat: '%s'", np->nn->lnode->name);
+
+  error_t err = 0;
+
+  /*If we are not at the root*/
+  if(np != netfs_root_node)
+    {
+      /*If the node is not surely up-to-date*/
+      if(!(np->nn->flags & FLAG_NODE_ULFS_UPTODATE))
+	{
+	  /*update it*/
+	  err = node_update(np);
+	}
+
+      /*If no errors have yet occurred*/
+      if(!err)
+	{
+	  /*If the port to the file corresponding to `np` is valid*/
+	  if(np->nn->port != MACH_PORT_NULL)
+	    {
+	      /*We have a directory here (normally, only they maintain an open port).
+		Generally, our only concern is to maintain an open port in this case*/
+
+	      /*attempt to stat this file*/
+	      err = io_stat(np->nn->port, &np->nn_stat);
+
+	      /*If stat information has been successfully obtained for the file*/
+	      if(!err)
+		/*duplicate the st_mode field of stat structure*/
+		np->nn_translated = np->nn_stat.st_mode;
+	    }
+	  else
+	    {
+	      /*We, most probably, have something which is not a directory. Therefore
+		we will open the port and close it after the stat, so that additional
+		resources are not consumed.*/
+
+	      /*the parent node of the current node*/
+	      node_t * dnp;
+
+	      /*obtain the parent node of the the current node*/
+	      err = ncache_node_lookup(np->nn->lnode->dir, &dnp);
+
+	      /*the lookup should never fail here*/
+	      assert(!err);
+
+	      /*open a port to the file we are interested in*/
+	      mach_port_t p = file_name_lookup_under
+		(dnp->nn->port, np->nn->lnode->name, 0, 0);
+
+	      /*put `dnp` back, since we don't need it any more*/
+	      netfs_nput(dnp);
+
+	      if(!p)
+		return EBADF;
+
+	      /*try to stat the node*/
+	      err = io_stat(p, &np->nn_stat);
+
+	      /*deallocate the port*/
+	      PORT_DEALLOC(p);
+	    }
+	}
+    }
+  /*If we are at the root*/
+  else
+    /*put the size of the node into the stat structure belonging to `np`*/
+    node_get_size(np, (OFFSET_T *)&np->nn_stat.st_size);
+
+  /*Return the result of operations*/
+  return err;
+}/*netfs_validate_stat*/
+/*----------------------------------------------------------------------------*/
+/*Syncs `node` completely to disk*/
+error_t
+netfs_attempt_sync
+(
+ struct iouser * cred,
+ struct node * node,
+ int wait
+)
+{
+  LOG_MSG("netfs_attempt_sync");
+
+  /*Operation is not supported*/
+  return EOPNOTSUPP;
+}/*netfs_attempt_sync*/
+/*----------------------------------------------------------------------------*/
+/*Fetches a directory*/
+error_t
+netfs_get_dirents
+(
+ struct iouser * cred,
+ struct node * dir,
+ int first_entry,
+ int num_entries,
+ char ** data,
+ mach_msg_type_number_t * data_len,
+ vm_size_t max_data_len,
+ int * data_entries
+)
+{
+  LOG_MSG("netfs_get_dirents: '%s'", dir->nn->lnode->name);
+
+  error_t err;
+
+  /*Two pointers required for processing the list of dirents*/
+  node_dirent_t * dirent_start, * dirent_current;
+
+  /*The pointer to the beginning of the list of dirents*/
+  node_dirent_t * dirent_list = NULL;
+
+  /*The size of the current dirent*/
+  size_t size = 0;
+
+  /*The number of dirents added*/
+  int count = 0;
+
+  /*The dereferenced value of parameter `data`*/
+  char * data_p;
+
+  /*Takes into account the size of the given dirent*/
+  int
+    bump_size
+    (
+     const char * name
+    )
+      {
+	/*If the required number of entries has not been listed yet*/
+	if((num_entries == -1) || (count < num_entries))
+	  {
+	    /*take the current size and take into account the length of the name*/
+	    size_t new_size = size + DIRENT_LEN(strlen(name));
+
+	    /*If there is a limit for the received size and it has been exceeded*/
+	    if((max_data_len > 0) && (new_size > max_data_len))
+	      /*a new dirent cannot be added*/
+	      return 0;
+
+	    /*memorize the new size*/
+	    size = new_size;
+
+	    /*increase the number of dirents added*/
+	    ++count;
+
+	    /*everything is OK*/
+	    return 1;
+	  }
+	else
+	  {
+	    /*dirents cannot be added*/
+	    return 0;
+	  }
+      }/*bump_size*/
+
+  /*Adds a dirent to the list of dirents*/
+  int
+    add_dirent
+    (
+     const char * name,
+     ino_t ino,
+     int type
+    )
+      {
+	/*If the required number of dirents has not been listed yet*/
+	if((num_entries == -1) || (count < num_entries))
+	  {
+	    /*create a new dirent*/
+	    struct dirent hdr;
+
+	    /*obtain the length of the name*/
+	    size_t name_len = strlen(name);
+
+	    /*compute the full size of the dirent*/
+	    size_t sz = DIRENT_LEN(name_len);
+
+	    /*If there is no room for this dirent*/
+	    if(sz > size)
+	      /*stop*/
+	      return 0;
+	    else
+	      /*take into account the fact that a new dirent has just been added*/
+	      size -= sz;
+
+	    /*setup the dirent*/
+	    hdr.d_ino 	 = ino;
+	    hdr.d_reclen = sz;
+	    hdr.d_type   = type;
+	    hdr.d_namlen = name_len;
+
+	    /*The following two lines of code reflect the old layout of
+	      dirents in the memory. Now libnetfs expects the layout
+	      identical to the layout provided by dir_readdir (see dir_entries_get)*/
+
+	    /*copy the header of the dirent into the final block of dirents*/
+	    memcpy(data_p, &hdr, DIRENT_NAME_OFFS);
+
+	    /*copy the name of the dirent into the block of dirents*/
+	    strcpy(data_p + DIRENT_NAME_OFFS, name);
+
+	    /*This line is commented for the same reason as the two specifically
+	      commented lines above.*/
+	    /*move the current pointer in the block of dirents*/
+	    data_p += sz;
+
+	    /*count the new dirent*/
+	    ++count;
+
+	    /*everything was OK, so say it*/
+	    return 1;
+	  }
+	else
+	  /*no [new] dirents allowed*/
+	  return 0;
+      }/*add_dirent*/
+
+  /*List the dirents for node `dir`*/
+  err = node_entries_get(dir, &dirent_list);
+
+  /*If listing was successful*/
+  if(!err)
+    {
+      /*find the entry whose number is `first_entry`*/
+      for
+	(
+	 dirent_start = dirent_list, count = 2;
+	 dirent_start && (count < first_entry);
+	 dirent_start = dirent_start->next, ++count
+	);
+
+      /*reset number of dirents added so far*/
+      count = 0;
+
+      /*make space for entries '.' and '..', if required*/
+      if(first_entry == 0)
+	bump_size(".");
+      if(first_entry <= 1)
+	bump_size("..");
+
+      /*Go through all dirents*/
+      for
+	(
+	 dirent_current = dirent_start;
+	 dirent_current;
+	 dirent_current = dirent_current->next
+	)
+	  /*If another dirent cannot be added succesfully*/
+	  if(bump_size(dirent_current->dirent->d_name) == 0)
+	    /*stop here*/
+	    break;
+
+      /*allocate the required space for dirents*/
+      *data = mmap(0, size, PROT_READ | PROT_WRITE, MAP_ANON, 0, 0);
+
+      /*check if any error occurred*/
+      err = ((void *)*data == MAP_FAILED) ? (errno) : (0);
+    }
+
+  /*If no errors have occurred so far*/
+  if(!err)
+    {
+      /*obtain the pointer to the beginning of the block of dirents*/
+      data_p = *data;
+
+      /*fill the parameters with useful values*/
+      *data_len = size;
+      *data_entries = count;
+
+      /*reset the number of dirents added*/
+      count = 0;
+
+      /*add entries '.' and '..', if required*/
+      if(first_entry == 0)
+	add_dirent(".", 2, DT_DIR);
+      if(first_entry <= 1)
+	add_dirent("..", 2, DT_DIR);
+
+      /*Follow the list of dirents beginning with dirents_start*/
+      for
+	(
+	 dirent_current = dirent_start; dirent_current;
+	 dirent_current = dirent_current->next
+	)
+	  /*If the addition of the current dirent fails*/
+	  if
+	    (
+	     add_dirent
+	     (dirent_current->dirent->d_name, dirent_current->dirent->d_fileno,
+	      dirent_current->dirent->d_type) == 0
+	    )
+	      /*stop adding dirents*/
+	      break;
+    }
+
+  /*If the list of dirents has been allocated, free it*/
+  if(dirent_list)
+    node_entries_free(dirent_list);
+
+  /*The directory has been read right now, modify the access time*/
+  fshelp_touch(&dir->nn_stat, TOUCH_ATIME, maptime);
+
+  /*Return the result of listing the dirents*/
+  return err;
+}/*netfs_get_dirents*/
+/*----------------------------------------------------------------------------*/
+/*Looks up `name` under `dir` for `user`*/
+error_t
+netfs_attempt_lookup
+(
+ struct iouser * user,
+ struct node * dir,
+ char * name,
+ struct node ** node
+)
+{
+  LOG_MSG("netfs_attempt_lookup: '%s'", name);
+
+  error_t err = 0;
+
+  /*If we are asked to fetch the current directory*/
+  if(strcmp(name, ".") == 0)
+    {
+      /*add a reference to `dir` and put it into `node`*/
+      netfs_nref(dir);
+      *node = dir;
+
+      /*everything is OK*/
+      return 0;
+    }
+  /*If we are asked to fetch the parent directory*/
+  else if(strcmp(name, "..") == 0)
+    {
+      /*If the supplied node is not root*/
+      if(dir->nn->lnode->dir)
+	{
+	  /*The node corresponding to the parent directory must exist here*/
+	  assert(dir->nn->lnode->dir->node);
+
+	  /*put the parent node of `dir` into the result*/
+	  err = ncache_node_lookup(dir->nn->lnode->dir, node);
+	}
+      /*The supplied node is root*/
+      else
+	{
+	  /*this node is not included into our filesystem*/
+	  err = ENOENT;
+	  *node = NULL;
+	}
+
+      /*unlock the directory*/
+      mutex_unlock(&dir->lock);
+
+      /*stop here*/
+      return err;
+    }
+
+  /*Checks whether the given name satisfied the required property*/
+  int
+    check_property
+    (
+     const char * name
+    )
+      {
+	/*If there is no property*/
+	if(!property)
+	  /*no filtering will be applied, any name is OK*/
+	  return 0;
+
+	/*The number of occurrences of PROPERTY_PARAM in the property*/
+	int param_entries_count = 0;
+
+	/*The pointer to the current occurrence of PROPERTY_PARAM*/
+	char * occurrence = strstr(property, PROPERTY_PARAM);
+
+	/*Count the number of occurrences*/
+	for(; occurrence;
+	    occurrence = strstr(occurrence + 1, PROPERTY_PARAM),
+	    ++param_entries_count);
+
+	/*Compute the length of the property param*/
+	size_t property_param_len = strlen(PROPERTY_PARAM);
+
+	/*The length of the property*/
+	size_t property_len = (property) ? (strlen(property)) : (0);
+
+	/*Everything OK at first*/
+	err = 0;
+
+	/*Compute the length of the full name once*/
+	size_t full_name_len = strlen(dir->nn->lnode->path) + 1 + strlen(name) + 1;
+
+	/*Try to allocate the required space*/
+	char * full_name = malloc(full_name_len);
+	if(!full_name)
+	  {
+	    err = ENOMEM;
+	    return 0;
+	  }
+
+	/*Initialize `full_name` as a valid string*/
+	full_name[0] = 0;
+
+	/*Construct the full name*/
+	strcpy(full_name, dir->nn->lnode->path);
+	strcat(full_name, "/");
+	strcat(full_name, name);
+
+	LOG_MSG("netfs_attempt_lookup: Applying filter to %s...", full_name);
+
+	/*Compute the space required for the final filtering command*/
+	size_t sz = property_len + (strlen(full_name) - property_param_len)
+	  * param_entries_count;
+
+	/*Try to allocate the space for the command*/
+	char * cmd = malloc(sz);
+	if(!cmd)
+	  {
+	    free(full_name);
+	    err = ENOMEM;
+	    return 0;
+	  }
+
+	/*Initialize `cmd` as a valid string*/
+	cmd[0] = 0;
+
+	/*The current occurence of PROPERTY_PARAM in property*/
+	char * p = strstr(property, PROPERTY_PARAM);
+
+	/*The pointer to the current position in the property*/
+	char * propp = property;
+
+	/*While the command has not been constructed*/
+	for(; p; p = strstr(propp, PROPERTY_PARAM))
+	  {
+	    /*add the new part of the property to the command*/
+	    strncat(cmd, propp, p - propp);
+
+	    /*add the filename to the command*/
+	    strcat(cmd, full_name);
+
+	    /*LOG_MSG("\tcmd = '%s'", cmd);*/
+
+	    /*advance the pointer in the property*/
+	    propp = p + property_param_len;
+
+	    /*LOG_MSG("\tpropp points at '%s'", propp);*/
+	  }
+
+	/*Copy the rest of the property to the command*/
+	strcat(cmd, propp);
+
+	/*LOG_MSG("node_entries_get: The filtering command: '%s'.", cmd);*/
+
+	/*Execute the command*/
+	int xcode = WEXITSTATUS(system(cmd));
+
+	/*Return the exit code of the command*/
+	return xcode;
+      }/*check_property*/
+
+  /*If the given name does not satisfy the property*/
+  if(check_property(name) != 0)
+    {
+      /*unlock the directory*/
+      mutex_unlock(&dir->lock);
+
+      /*no such file in the directory*/
+      return ENOENT;
+    }
+
+  /*Try to lookup the given file in the underlying directory*/
+  mach_port_t p = file_name_lookup_under(dir->nn->port, name, 0, 0);
+
+  /*If the lookup failed*/
+  if(p == MACH_PORT_NULL)
+    {
+      /*unlock the directory*/
+      mutex_unlock(&dir->lock);
+
+      /*no such entry*/
+      return ENOENT;
+    }
+
+  /*Obtain the stat information about the file*/
+  io_statbuf_t stat;
+  err = io_stat(p, &stat);
+
+  /*Deallocate the obtained port*/
+  PORT_DEALLOC(p);
+
+  /*If this file is not a directory*/
+  if(err || !S_ISDIR(stat.st_mode))
+    {
+      /*do not set the port*/
+      p = MACH_PORT_NULL;
+    }
+  else
+    {
+      /*lookup the port with the right to read the contents of the directory*/
+      p = file_name_lookup_under(dir->nn->port, name, O_READ | O_DIRECTORY, 0);
+      if(p == MACH_PORT_NULL)
+	{
+	  return EBADF; /*not enough rights?*/
+	}
+    }
+
+  /*The lnode corresponding to the entry we are supposed to fetch*/
+  lnode_t * lnode;
+
+  /*Finalizes the execution of this function*/
+  void
+    finalize(void)
+      {
+	/*If some errors have occurred*/
+	if(err)
+	  {
+	    /*the user should receive nothing*/
+	    *node = NULL;
+
+	    /*If there is some port, free it*/
+	    if(p != MACH_PORT_NULL)
+	      PORT_DEALLOC(p);
+	  }
+	/*If there is a node to return*/
+	if(*node)
+	  {
+	    /*unlock the node*/
+	    mutex_unlock(&(*node)->lock);
+
+	    /*add the node to the cache*/
+	    ncache_node_add(*node);
+	  }
+
+	/*Unlock the mutexes in `dir`*/
+	mutex_unlock(&dir->nn->lnode->lock);
+	mutex_unlock(&dir->lock);
+      }/*finalize*/
+
+  /*Try to find an lnode called `name` under the lnode corresponding to `dir`*/
+  err = lnode_get(dir->nn->lnode, name, &lnode);
+
+  /*If such an entry does not exist*/
+  if(err == ENOENT)
+    {
+      /*create a new lnode with the supplied name*/
+      err = lnode_create(name, &lnode);
+      if(err)
+	{
+	  finalize();
+	  return err;
+	}
+
+      /*install the new lnode into the directory*/
+      lnode_install(dir->nn->lnode, lnode);
+    }
+
+  /*Obtain the node corresponding to this lnode*/
+  err = ncache_node_lookup(lnode, node);
+
+  /*Remove an extra reference from the lnode*/
+  lnode_ref_remove(lnode);
+
+  /*If the lookup in the cache failed*/
+  if(err)
+    {
+      /*stop*/
+      finalize();
+      return err;
+    }
+
+  /*Store the port in the node*/
+  (*node)->nn->port = p;
+
+  /*Construct the full path to the node*/
+  err = lnode_path_construct(lnode, NULL);
+  if(err)
+    {
+      finalize();
+      return err;
+    }
+
+  /*Now the node is up-to-date*/
+  (*node)->nn->flags = FLAG_NODE_ULFS_UPTODATE;
+
+  /*Return the result of performing the operations*/
+  finalize();
+  return err;
+}/*netfs_attempt_lookup*/
+/*----------------------------------------------------------------------------*/
+/*Deletes `name` in `dir` for `user`*/
+error_t
+netfs_attempt_unlink
+(
+ struct iouser * user,
+ struct node * dir,
+ char * name
+)
+{
+  LOG_MSG("netfs_attempt_unlink");
+
+  return 0;
+}/*netfs_attempt_unlink*/
+/*----------------------------------------------------------------------------*/
+/*Attempts to rename `fromdir`/`fromname` to `todir`/`toname`*/
+error_t
+netfs_attempt_rename
+(
+ struct iouser * user,
+ struct node * fromdir,
+ char * fromname,
+ struct node * todir,
+ char * toname,
+ int excl
+)
+{
+  LOG_MSG("netfs_attempt_rename");
+
+  /*Operation not supported*/
+  return EOPNOTSUPP;
+}/*netfs_attempt_rename*/
+/*----------------------------------------------------------------------------*/
+/*Attempts to create a new directory*/
+error_t
+netfs_attempt_mkdir
+(
+ struct iouser * user,
+ struct node * dir,
+ char * name,
+ mode_t mode
+)
+{
+  LOG_MSG("netfs_attempt_mkdir");
+
+  return 0;
+}/*netfs_attempt_mkdir*/
+/*----------------------------------------------------------------------------*/
+/*Attempts to remove directory `name` in `dir` for `user`*/
+error_t
+netfs_attempt_rmdir
+(
+ struct iouser * user,
+ struct node * dir,
+ char * name
+)
+{
+  LOG_MSG("netfs_attempt_rmdir");
+
+  return 0;
+}/*netfs_attempt_rmdir*/
+/*----------------------------------------------------------------------------*/
+/*Attempts to change the mode of `node` for user `cred` to `uid`:`gid`*/
+error_t
+netfs_attempt_chown
+(
+ struct iouser * cred,
+ struct node * node,
+ uid_t uid,
+ uid_t gid
+)
+{
+  LOG_MSG("netfs_attempt_chown");
+
+  /*Operation is not supported*/
+  return EOPNOTSUPP;
+}/*netfs_attempt_chown*/
+/*----------------------------------------------------------------------------*/
+/*Attempts to change the author of `node` to `author`*/
+error_t
+netfs_attempt_chauthor
+(
+ struct iouser * cred,
+ struct node * node,
+ uid_t author
+)
+{
+  LOG_MSG("netfs_attempt_chauthor");
+
+  /*Operation is not supported*/
+  return EOPNOTSUPP;
+}/*netfs_attempt_chauthor*/
+/*----------------------------------------------------------------------------*/
+/*Attempts to change the mode of `node` to `mode` for `cred`*/
+error_t
+netfs_attempt_chmod
+(
+ struct iouser * user,
+ struct node * node,
+ mode_t mode
+)
+{
+  LOG_MSG("netfs_attempt_chmod");
+
+  /*Operation is not supported*/
+  return EOPNOTSUPP;
+}/*netfs_attempt_chmod*/
+/*----------------------------------------------------------------------------*/
+/*Attempts to turn `node` into a symlink targetting `name`*/
+error_t
+netfs_attempt_mksymlink
+(
+ struct iouser * cred,
+ struct node * node,
+ char * name
+)
+{
+  LOG_MSG("netfs_attempt_mksymlink");
+
+  /*Operation is not supported*/
+  return EOPNOTSUPP;
+}/*netfs_attempt_mksymlink*/
+/*----------------------------------------------------------------------------*/
+/*Attempts to turn `node` into a device; type can be either S_IFBLK or S_IFCHR*/
+error_t
+netfs_attempt_mkdev
+(
+ struct iouser * cred,
+ struct node * node,
+ mode_t type,
+ dev_t indexes
+)
+{
+  LOG_MSG("netfs_attempt_mkdev");
+
+  /*Operation is not supported*/
+  return EOPNOTSUPP;
+}/*netfs_attempt_mkdev*/
+/*----------------------------------------------------------------------------*/
+/*Attempts to set the passive translator record for `file` passing `argz`*/
+error_t
+netfs_set_translator
+(
+ struct iouser * cred,
+ struct node * node,
+ char * argz,
+ size_t arglen
+)
+{
+  LOG_MSG("netfs_set_translator");
+
+  /*Operation is not supported*/
+  return EOPNOTSUPP;
+}/*netfs_set_translator	*/
+/*----------------------------------------------------------------------------*/
+/*Attempts to call chflags for `node`*/
+error_t
+netfs_attempt_chflags
+(
+ struct iouser * cred,
+ struct node * node,
+ int flags
+)
+{
+  LOG_MSG("netfs_attempt_chflags");
+
+  /*Operation is not supported*/
+  return EOPNOTSUPP;
+}/*netfs_attempt_chflags*/
+/*----------------------------------------------------------------------------*/
+/*Attempts to set the size of file `node`*/
+error_t
+netfs_attempt_set_size
+(
+ struct iouser * cred,
+ struct node * node,
+ loff_t size
+)
+{
+  LOG_MSG("netfs_attempt_set_size");
+
+  /*Operation is not supported*/
+  return EOPNOTSUPP;
+}/*netfs_attempt_set_size*/
+/*----------------------------------------------------------------------------*/
+/*Fetches the filesystem status information*/
+error_t
+netfs_attempt_statfs
+(
+ struct iouser * cred,
+ struct node * node,
+ fsys_statfsbuf_t * st
+)
+{
+  LOG_MSG("netfs_attempt_statfs");
+
+  /*Operation is not supported*/
+  return EOPNOTSUPP;
+}/*netfs_attempt_statfs*/
+/*----------------------------------------------------------------------------*/
+/*Syncs the filesystem*/
+error_t
+netfs_attempt_syncfs
+(
+ struct iouser * cred,
+ int wait
+)
+{
+  LOG_MSG("netfs_attempt_syncfs");
+
+  /*Everythin OK*/
+  return 0;
+}/*netfs_attempt_syncfs*/
+/*----------------------------------------------------------------------------*/
+/*Creates a link in `dir` with `name` to `file`*/
+error_t
+netfs_attempt_link
+(
+ struct iouser * user,
+ struct node * dir,
+ struct node * file,
+ char * name,
+ int excl
+)
+{
+  LOG_MSG("netfs_attempt_link");
+
+  /*Operation not supported*/
+  return EOPNOTSUPP;
+}/*netfs_attempt_link*/
+/*----------------------------------------------------------------------------*/
+/*Attempts to create an anonymous file related to `dir` with `mode`*/
+error_t
+netfs_attempt_mkfile
+(
+ struct iouser * user,
+ struct node * dir,
+ mode_t mode,
+ struct node ** node
+)
+{
+  LOG_MSG("netfs_attempt_mkfile");
+
+  /*Unlock the directory*/
+  mutex_unlock(&dir->lock);
+
+  /*Operation not supported*/
+  return EOPNOTSUPP;
+}/*netfs_attempt_mkfile*/
+/*----------------------------------------------------------------------------*/
+/*Reads the contents of symlink `node` into `buf`*/
+error_t
+netfs_attempt_readlink
+(
+ struct iouser * user,
+ struct node * node,
+ char * buf
+)
+{
+  LOG_MSG("netfs_attempt_readlink");
+
+  /*Operation not supported (why?..)*/
+  return EOPNOTSUPP;
+}/*netfs_attempt_readlink*/
+/*----------------------------------------------------------------------------*/
+/*Reads from file `node` up to `len` bytes from `offset` into `data`*/
+error_t
+netfs_attempt_read
+(
+ struct iouser * cred,
+ struct node * np,
+ loff_t offset,
+ size_t * len,
+ void * data
+)
+{
+  LOG_MSG("netfs_attempt_read");
+
+  error_t err = 0;
+
+  /*If there is no port open for the current node*/
+  if(np->nn->port == MACH_PORT_NULL)
+    {
+      /*the parent node of the current node*/
+      node_t * dnp;
+
+      /*obtain the parent node of the the current node*/
+      err = ncache_node_lookup(np->nn->lnode->dir, &dnp);
+
+      /*the lookup should never fail here*/
+      assert(!err);
+
+      /*open a port to the file we are interested in*/
+      mach_port_t p = file_name_lookup_under
+	(dnp->nn->port, np->nn->lnode->name, O_READ, 0);
+
+      /*put `dnp` back, since we don't need it any more*/
+      netfs_nput(dnp);
+
+      if(!p)
+	return EBADF;
+
+      /*store the port in the node*/
+      np->nn->port = p;
+    }
+
+  /*Read the required data from the file*/
+  err = io_read(np->nn->port, (char **)&data, len, offset, *len);
+
+  /*Return the result of reading*/
+  return err;
+}/*netfs_attempt_read*/
+/*----------------------------------------------------------------------------*/
+/*Writes to file `node` up to `len` bytes from offset from `data`*/
+error_t
+netfs_attempt_write
+(
+ struct iouser * cred,
+ struct node * node,
+ loff_t offset,
+ size_t * len,
+ void * data
+)
+{
+  LOG_MSG("netfs_attempt_write");
+
+  return 0;
+}/*netfs_attempt_write*/
+/*----------------------------------------------------------------------------*/
+/*Frees all storage associated with the node*/
+void
+netfs_node_norefs
+(
+ struct node * np
+)
+{
+  /*Destroy the node*/
+  node_destroy(np);
+}/*netfs_node_norefs*/
+/*----------------------------------------------------------------------------*/
+/*Entry point*/
+int
+main
+(
+ int argc,
+ char ** argv
+)
+{
+  /*Start logging*/
+  INIT_LOG();
+  LOG_MSG(">> Starting initialization...");
+
+  /*The port on which this translator will be set upon*/
+  mach_port_t bootstrap_port;
+
+  error_t err = 0;
+
+  /*Parse the command line arguments*/
+  argp_parse(&argp_startup, argc, argv, ARGP_IN_ORDER, 0, 0);
+  LOG_MSG("Command line arguments parsed.");
+
+  /*Try to create the root node*/
+  err = node_create_root(&netfs_root_node);
+  if(err)
+    error(EXIT_FAILURE, err, "Failed to create the root node");
+  LOG_MSG("Root node created.");
+
+  /*Obtain the bootstrap port*/
+  task_get_bootstrap_port(mach_task_self(), &bootstrap_port);
+
+  /*Initialize the translator*/
+  netfs_init();
+
+  /*Obtain a port to the underlying node*/
+  underlying_node = netfs_startup(bootstrap_port, O_READ);
+  LOG_MSG("netfs initialization complete.");
+
+  /*Initialize the root node*/
+  err = node_init_root(netfs_root_node);
+  if(err)
+    error(EXIT_FAILURE, err, "Failed to initialize the root node");
+  LOG_MSG("Root node initialized.");
+  LOG_MSG("\tRoot node address: 0x%lX", (unsigned long)netfs_root_node);
+
+  /*Map the time for updating node information*/
+  err = maptime_map(0, 0, &maptime);
+  if(err)
+    error(EXIT_FAILURE, err, "Failed to map the time");
+  LOG_MSG("Time mapped.");
+
+  /*Initialize the cache with the required number of nodes*/
+  ncache_init(ncache_size);
+  LOG_MSG("Cache initialized.");
+
+  /*Obtain stat information about the underlying node*/
+  err = io_stat(underlying_node, &underlying_node_stat);
+  if(err)
+    error(EXIT_FAILURE, err,
+	  "Cannot obtain stat information about the underlying node");
+  LOG_MSG("Stat information for undelying node obtained.");
+
+  /*Obtain the ID of the current process*/
+  fsid = getpid();
+
+  /*Setup the stat information for the root node*/
+  netfs_root_node->nn_stat = underlying_node_stat;
+
+  netfs_root_node->nn_stat.st_ino 	= FILTERFS_ROOT_INODE;
+  netfs_root_node->nn_stat.st_fsid	= fsid;
+  netfs_root_node->nn_stat.st_mode = S_IFDIR | (underlying_node_stat.st_mode
+						& ~S_IFMT & ~S_ITRANS); /*we are providing a translated directory*/
+
+  netfs_root_node->nn_translated = netfs_root_node->nn_stat.st_mode;
+
+  /*If the underlying node is not a directory, enhance the permissions
+    of the root node of filterfs*/
+  if(!S_ISDIR(underlying_node_stat.st_mode))
+    {
+      /*can be read by owner*/
+      if(underlying_node_stat.st_mode & S_IRUSR)
+	/*allow execution by the owner*/
+	netfs_root_node->nn_stat.st_mode |= S_IXUSR;
+      /*can be read by group*/
+      if(underlying_node_stat.st_mode & S_IRGRP)
+	/*allow execution by the group*/
+	netfs_root_node->nn_stat.st_mode |= S_IXGRP;
+      /*can be read by others*/
+      if(underlying_node_stat.st_mode & S_IROTH)
+	/*allow execution by the others*/
+	netfs_root_node->nn_stat.st_mode |= S_IXOTH;
+    }
+
+  /*Update the timestamps of the root node*/
+  fshelp_touch
+    (&netfs_root_node->nn_stat, TOUCH_ATIME | TOUCH_MTIME | TOUCH_CTIME,
+     maptime);
+
+  LOG_MSG(">> Initialization complete. Entering netfs server loop...");
+
+  /*Start serving clients*/
+  for(;;)
+    netfs_server_loop();
+}/*main*/
+/*----------------------------------------------------------------------------*/
diff --git a/netfs-sample/filterfs.c~ b/netfs-sample/filterfs.c~
new file mode 100644
index 00000000..5aaacf75
--- /dev/null
+++ b/netfs-sample/filterfs.c~
@@ -0,0 +1,1236 @@
+/*----------------------------------------------------------------------------*/
+/*filter.c*/
+/*----------------------------------------------------------------------------*/
+/*The filtering translator*/
+/*----------------------------------------------------------------------------*/
+/*Based on the code of unionfs translator.*/
+/*----------------------------------------------------------------------------*/
+/*Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
+  Written by Sergiu Ivanov <unlimitedscolobb@gmail.com>.
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or * (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+#define _GNU_SOURCE 1
+/*----------------------------------------------------------------------------*/
+#include "filterfs.h"
+/*----------------------------------------------------------------------------*/
+#include <error.h>
+#include <argp.h>
+#include <argz.h>
+#include <hurd/netfs.h>
+#include <fcntl.h>
+/*----------------------------------------------------------------------------*/
+#include "debug.h"
+#include "options.h"
+#include "ncache.h"
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Macros--------------------------------------------------------------*/
+/*The state modes use in open*/
+#define OPENONLY_STATE_MODES (O_CREAT | O_EXCL | O_NOLINK | O_NOTRANS \
+	| O_NONBLOCK)
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Global Variables----------------------------------------------------*/
+/*The name of the server*/
+char * netfs_server_name = "filterfs";
+/*----------------------------------------------------------------------------*/
+/*The version of the server*/
+char * netfs_server_version = "0.0";
+/*----------------------------------------------------------------------------*/
+/*The maximal length of a chain of symbolic links*/
+int netfs_maxsymlinks = 12;
+/*----------------------------------------------------------------------------*/
+/*A port to the underlying node*/
+mach_port_t underlying_node;
+/*----------------------------------------------------------------------------*/
+/*Status information for the underlying node*/
+io_statbuf_t underlying_node_stat;
+/*----------------------------------------------------------------------------*/
+/*Mapped time used for updating node information*/
+volatile struct mapped_time_value * maptime;
+/*----------------------------------------------------------------------------*/
+/*The filesystem ID*/
+pid_t fsid;
+/*----------------------------------------------------------------------------*/
+/*The file to print debug messages to*/
+FILE * filterfs_dbg;
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Functions-----------------------------------------------------------*/
+/*Attempts to create a file named `name` in `dir` for `user` with mode `mode`*/
+error_t
+netfs_attempt_create_file
+	(
+	struct iouser * user,
+	struct node * dir,
+	char * name,
+	mode_t mode,
+	struct node ** node
+	)
+	{
+	LOG_MSG("netfs_attempt_create_file");
+
+	/*Unlock `dir` and say that we can do nothing else here*/
+	mutex_unlock(&dir->lock);
+	return EOPNOTSUPP;
+	}/*netfs_attempt_create_file*/
+/*----------------------------------------------------------------------------*/
+/*Return an error if the process of opening a file should not be allowed
+	to complete because of insufficient permissions*/
+error_t
+netfs_check_open_permissions
+	(
+	struct iouser * user,
+	struct node * np,
+	int flags,
+	int newnode
+	)
+	{
+	LOG_MSG("netfs_check_open_permissions: '%s'", np->nn->lnode->name);
+
+	error_t err = 0;
+	
+	/*Cheks user's permissions*/
+	if(flags & O_READ)
+		err = fshelp_access(&np->nn_stat, S_IREAD, user);
+	if(!err && (flags & O_WRITE))
+		err = fshelp_access(&np->nn_stat, S_IWRITE, user);
+	if(!err && (flags & O_EXEC))
+		err = fshelp_access(&np->nn_stat, S_IEXEC, user);
+		
+	/*Return the result of the check*/
+	return err;
+	}/*netfs_check_open_permissions*/
+/*----------------------------------------------------------------------------*/
+/*Attempts an utimes call for the user `cred` on node `node`*/
+error_t
+netfs_attempt_utimes
+	(
+	struct iouser * cred,
+	struct node * node,
+	struct timespec * atime,
+	struct timespec * mtime
+	)
+	{
+	LOG_MSG("netfs_attempt_utimes");
+
+	error_t err = 0;
+	
+	/*See what information is to be updated*/
+	int flags = TOUCH_CTIME;
+	
+	/*Check if the user is indeed the owner of the node*/
+	err = fshelp_isowner(&node->nn_stat, cred);
+	
+	/*If the user is allowed to do utimes*/
+	if(!err)
+		{
+		/*If atime is to be updated*/
+		if(atime)
+			/*update the atime*/
+			node->nn_stat.st_atim = *atime;
+		else
+			/*the current time will be set as the atime*/
+			flags |= TOUCH_ATIME;
+		
+		/*If mtime is to be updated*/
+		if(mtime)
+			/*update the mtime*/
+			node->nn_stat.st_mtim = *mtime;
+		else
+			/*the current time will be set as mtime*/
+			flags |= TOUCH_MTIME;
+		
+		/*touch the file*/
+		fshelp_touch(&node->nn_stat, flags, maptime);
+		}
+	
+	/*Return the result of operations*/
+	return err;
+	}/*netfs_attempt_utimes*/
+/*----------------------------------------------------------------------------*/
+/*Returns the valid access types for file `node` and user `cred`*/
+error_t
+netfs_report_access
+	(
+	struct iouser * cred,
+	struct node * np,
+	int * types
+	)
+	{
+	LOG_MSG("netfs_report_access");
+
+	/*No access at first*/
+	*types = 0;
+	
+	/*Check the access and set the required bits*/
+	if(fshelp_access(&np->nn_stat, S_IREAD,  cred) == 0)
+		*types |= O_READ;
+	if(fshelp_access(&np->nn_stat, S_IWRITE, cred) == 0)
+		*types |= O_WRITE;
+	if(fshelp_access(&np->nn_stat, S_IEXEC,  cred) == 0)
+		*types |= O_EXEC;
+
+	/*Everything OK*/
+	return 0;
+	}/*netfs_report_access*/
+/*----------------------------------------------------------------------------*/
+/*Validates the stat data for the node*/
+error_t
+netfs_validate_stat
+	(
+	struct node * np,
+	struct iouser * cred
+	)
+	{
+	LOG_MSG("netfs_validate_stat: '%s'", np->nn->lnode->name);
+
+	error_t err = 0;
+	
+	/*If we are not at the root*/
+	if(np != netfs_root_node)
+		{
+		/*If the node is not surely up-to-date*/
+		if(!(np->nn->flags & FLAG_NODE_ULFS_UPTODATE))
+			{
+			/*update it*/
+			err = node_update(np);
+			}
+		
+		/*If no errors have yet occurred*/
+		if(!err)
+			{
+			/*If the port to the file corresponding to `np` is valid*/
+			if(np->nn->port != MACH_PORT_NULL)
+				{
+				/*We have a directory here (normally, only they maintain an open port).
+					Generally, our only concern is to maintain an open port in this case*/
+				
+				/*attempt to stat this file*/
+				err = io_stat(np->nn->port, &np->nn_stat);
+
+				/*If stat information has been successfully obtained for the file*/
+				if(!err)
+					/*duplicate the st_mode field of stat structure*/
+					np->nn_translated = np->nn_stat.st_mode;
+				}
+			else
+				{
+				/*We, most probably, have something which is not a directory. Therefore
+					we will open the port and close it after the stat, so that additional
+					resources are not consumed.*/
+				
+				/*the parent node of the current node*/
+				node_t * dnp;
+
+				/*obtain the parent node of the the current node*/
+				err = ncache_node_lookup(np->nn->lnode->dir, &dnp);
+				
+				/*the lookup should never fail here*/
+				assert(!err);
+				
+				/*open a port to the file we are interested in*/
+				mach_port_t p = file_name_lookup_under
+					(dnp->nn->port, np->nn->lnode->name, 0, 0);
+	
+				/*put `dnp` back, since we don't need it any more*/
+				netfs_nput(dnp);
+
+				if(!p)
+					return EBADF;
+				
+				/*try to stat the node*/
+				err = io_stat(p, &np->nn_stat);
+				
+				/*deallocate the port*/
+				PORT_DEALLOC(p);
+				}
+			}
+		}
+	/*If we are at the root*/
+	else
+		/*put the size of the node into the stat structure belonging to `np`*/
+		node_get_size(np, (OFFSET_T *)&np->nn_stat.st_size);
+
+	/*Return the result of operations*/
+	return err;
+	}/*netfs_validate_stat*/
+/*----------------------------------------------------------------------------*/
+/*Syncs `node` completely to disk*/
+error_t
+netfs_attempt_sync
+	(
+	struct iouser * cred,
+	struct node * node,
+	int wait
+	)
+	{
+	LOG_MSG("netfs_attempt_sync");
+
+	/*Operation is not supported*/
+	return EOPNOTSUPP;
+	}/*netfs_attempt_sync*/
+/*----------------------------------------------------------------------------*/
+/*Fetches a directory*/
+error_t
+netfs_get_dirents
+	(
+	struct iouser * cred,
+	struct node * dir,
+	int first_entry,
+	int num_entries,
+	char ** data,
+	mach_msg_type_number_t * data_len,
+	vm_size_t max_data_len,
+	int * data_entries
+	)
+	{
+	LOG_MSG("netfs_get_dirents: '%s'", dir->nn->lnode->name);
+
+	error_t err;
+
+	/*Two pointers required for processing the list of dirents*/
+	node_dirent_t * dirent_start, * dirent_current;
+	
+	/*The pointer to the beginning of the list of dirents*/
+	node_dirent_t * dirent_list = NULL;
+	
+	/*The size of the current dirent*/
+	size_t size = 0;
+	
+	/*The number of dirents added*/
+	int count = 0;
+	
+	/*The dereferenced value of parameter `data`*/
+	char * data_p;
+	
+	/*Takes into account the size of the given dirent*/
+	int
+	bump_size
+		(
+		const char * name
+		)
+		{
+		/*If the required number of entries has not been listed yet*/
+		if((num_entries == -1) || (count < num_entries))
+			{
+			/*take the current size and take into account the length of the name*/
+			size_t new_size = size + DIRENT_LEN(strlen(name));
+			
+			/*If there is a limit for the received size and it has been exceeded*/
+			if((max_data_len > 0) && (new_size > max_data_len))
+				/*a new dirent cannot be added*/
+				return 0;
+				
+			/*memorize the new size*/
+			size = new_size;
+			
+			/*increase the number of dirents added*/
+			++count;
+			
+			/*everything is OK*/
+			return 1;
+			}
+		else
+			{
+			/*dirents cannot be added*/
+			return 0;
+			}
+		}/*bump_size*/
+		
+	/*Adds a dirent to the list of dirents*/
+	int
+	add_dirent
+		(
+		const char * name,
+		ino_t ino,
+		int type
+		)
+		{
+		/*If the required number of dirents has not been listed yet*/
+		if((num_entries == -1) || (count < num_entries))
+			{
+			/*create a new dirent*/
+			struct dirent hdr;
+
+			/*obtain the length of the name*/
+			size_t name_len = strlen(name);
+			
+			/*compute the full size of the dirent*/
+			size_t sz = DIRENT_LEN(name_len);
+			
+			/*If there is no room for this dirent*/
+			if(sz > size)
+				/*stop*/
+				return 0;
+			else
+				/*take into account the fact that a new dirent has just been added*/
+				size -= sz;
+				
+			/*setup the dirent*/
+			hdr.d_ino 	 = ino;
+			hdr.d_reclen = sz;
+			hdr.d_type   = type;
+			hdr.d_namlen = name_len;
+			
+			/*The following two lines of code reflect the old layout of
+				dirents in the memory. Now libnetfs expects the layout
+				identical to the layout provided by dir_readdir (see dir_entries_get)*/
+
+			/*copy the header of the dirent into the final block of dirents*/
+			memcpy(data_p, &hdr, DIRENT_NAME_OFFS);
+			
+			/*copy the name of the dirent into the block of dirents*/
+			strcpy(data_p + DIRENT_NAME_OFFS, name);
+			
+			/*This line is commented for the same reason as the two specifically
+				commented lines above.*/
+			/*move the current pointer in the block of dirents*/
+			data_p += sz;
+			
+			/*count the new dirent*/
+			++count;
+			
+			/*everything was OK, so say it*/
+			return 1;
+			}
+		else
+			/*no [new] dirents allowed*/
+			return 0;
+		}/*add_dirent*/
+	
+	/*List the dirents for node `dir`*/
+	err = node_entries_get(dir, &dirent_list);
+	
+	/*If listing was successful*/
+	if(!err)
+		{
+		/*find the entry whose number is `first_entry`*/
+		for
+			(
+			dirent_start = dirent_list, count = 2;
+			dirent_start && (count < first_entry);
+			dirent_start = dirent_start->next, ++count
+			);
+			
+		/*reset number of dirents added so far*/
+		count = 0;
+		
+		/*make space for entries '.' and '..', if required*/
+		if(first_entry == 0)
+			bump_size(".");
+		if(first_entry <= 1)
+			bump_size("..");
+			
+		/*Go through all dirents*/
+		for
+			(
+			dirent_current = dirent_start;
+			dirent_current;
+			dirent_current = dirent_current->next
+			)
+			/*If another dirent cannot be added succesfully*/
+			if(bump_size(dirent_current->dirent->d_name) == 0)
+				/*stop here*/
+				break;
+				
+		/*allocate the required space for dirents*/
+		*data = mmap(0, size, PROT_READ | PROT_WRITE, MAP_ANON, 0, 0);
+		
+		/*check if any error occurred*/
+		err = ((void *)*data == MAP_FAILED) ? (errno) : (0);
+		}
+		
+	/*If no errors have occurred so far*/
+	if(!err)
+		{
+		/*obtain the pointer to the beginning of the block of dirents*/
+		data_p = *data;
+
+		/*fill the parameters with useful values*/
+		*data_len = size;
+		*data_entries = count;
+		
+		/*reset the number of dirents added*/
+		count = 0;
+
+		/*add entries '.' and '..', if required*/
+		if(first_entry == 0)
+			add_dirent(".", 2, DT_DIR);
+		if(first_entry <= 1)
+			add_dirent("..", 2, DT_DIR);
+
+		/*Follow the list of dirents beginning with dirents_start*/
+		for
+			(
+			dirent_current = dirent_start; dirent_current;
+			dirent_current = dirent_current->next
+			)
+			/*If the addition of the current dirent fails*/
+			if
+				(
+				add_dirent
+					(dirent_current->dirent->d_name, dirent_current->dirent->d_fileno,
+					dirent_current->dirent->d_type) == 0
+				)
+				/*stop adding dirents*/
+				break;
+		}
+		
+	/*If the list of dirents has been allocated, free it*/
+	if(dirent_list)
+		node_entries_free(dirent_list);
+		
+	/*The directory has been read right now, modify the access time*/
+	fshelp_touch(&dir->nn_stat, TOUCH_ATIME, maptime);
+	
+	/*Return the result of listing the dirents*/
+	return err;
+	}/*netfs_get_dirents*/
+/*----------------------------------------------------------------------------*/
+/*Looks up `name` under `dir` for `user`*/
+error_t
+netfs_attempt_lookup
+	(
+	struct iouser * user,
+	struct node * dir,
+	char * name,
+	struct node ** node
+	)
+	{
+	LOG_MSG("netfs_attempt_lookup: '%s'", name);
+
+	error_t err = 0;
+
+	/*If we are asked to fetch the current directory*/
+	if(strcmp(name, ".") == 0)
+		{
+		/*add a reference to `dir` and put it into `node`*/
+		netfs_nref(dir);
+		*node = dir;
+		
+		/*everything is OK*/
+		return 0;
+		}
+	/*If we are asked to fetch the parent directory*/
+	else if(strcmp(name, "..") == 0)
+		{
+		/*If the supplied node is not root*/
+		if(dir->nn->lnode->dir)
+			{
+			/*The node corresponding to the parent directory must exist here*/
+			assert(dir->nn->lnode->dir->node);
+			
+			/*put the parent node of `dir` into the result*/
+			err = ncache_node_lookup(dir->nn->lnode->dir, node);
+			}
+		/*The supplied node is root*/
+		else
+			{
+			/*this node is not included into our filesystem*/
+			err = ENOENT;
+			*node = NULL;
+			}
+			
+		/*unlock the directory*/
+		mutex_unlock(&dir->lock);
+		
+		/*stop here*/
+		return err;
+		}
+
+	/*Checks whether the given name satisfied the required property*/
+	int
+	check_property
+		(
+		const char * name
+		)
+		{
+		/*If there is no property*/
+		if(!property)
+			/*no filtering will be applied, any name is OK*/
+			return 0;
+		
+		/*The number of occurrences of PROPERTY_PARAM in the property*/
+		int param_entries_count = 0;
+
+		/*The pointer to the current occurrence of PROPERTY_PARAM*/
+		char * occurrence = strstr(property, PROPERTY_PARAM);
+		
+		/*Count the number of occurrences*/
+		for(; occurrence;
+			occurrence = strstr(occurrence + 1, PROPERTY_PARAM),
+			++param_entries_count);
+		
+		/*Compute the length of the property param*/
+		size_t property_param_len = strlen(PROPERTY_PARAM);
+		
+		/*The length of the property*/
+		size_t property_len = (property) ? (strlen(property)) : (0);
+	
+		/*Everything OK at first*/
+		err = 0;
+		
+		/*Compute the length of the full name once*/
+		size_t full_name_len = strlen(dir->nn->lnode->path) + 1 + strlen(name) + 1;
+		
+		/*Try to allocate the required space*/
+		char * full_name = malloc(full_name_len);
+		if(!full_name)
+			{
+			err = ENOMEM;
+			return 0;
+			}
+		
+		/*Initialize `full_name` as a valid string*/
+		full_name[0] = 0;
+		
+		/*Construct the full name*/
+		strcpy(full_name, dir->nn->lnode->path);
+		strcat(full_name, "/");
+		strcat(full_name, name);
+		
+		LOG_MSG("netfs_attempt_lookup: Applying filter to %s...", full_name);
+		
+		/*Compute the space required for the final filtering command*/
+		size_t sz = property_len + (strlen(full_name) - property_param_len)
+			* param_entries_count;
+		
+		/*Try to allocate the space for the command*/
+		char * cmd = malloc(sz);
+		if(!cmd)
+			{
+			free(full_name);
+			err = ENOMEM;
+			return 0;
+			}
+		
+		/*Initialize `cmd` as a valid string*/
+		cmd[0] = 0;
+			
+		/*The current occurence of PROPERTY_PARAM in property*/
+		char * p = strstr(property, PROPERTY_PARAM);
+		
+		/*The pointer to the current position in the property*/
+		char * propp = property;
+		
+		/*While the command has not been constructed*/
+		for(; p; p = strstr(propp, PROPERTY_PARAM))
+			{
+			/*add the new part of the property to the command*/
+			strncat(cmd, propp, p - propp);
+			
+			/*add the filename to the command*/
+			strcat(cmd, full_name);
+			
+			/*LOG_MSG("\tcmd = '%s'", cmd);*/
+
+			/*advance the pointer in the property*/
+			propp = p + property_param_len;
+
+			/*LOG_MSG("\tpropp points at '%s'", propp);*/
+			}
+		
+		/*Copy the rest of the property to the command*/
+		strcat(cmd, propp);
+		
+		/*LOG_MSG("node_entries_get: The filtering command: '%s'.", cmd);*/
+
+		/*Execute the command*/
+		int xcode = WEXITSTATUS(system(cmd));
+		
+		/*Return the exit code of the command*/
+		return xcode;
+		}/*check_property*/
+
+	/*If the given name does not satisfy the property*/
+	if(check_property(name) != 0)
+		{
+		/*unlock the directory*/
+		mutex_unlock(&dir->lock);
+
+		/*no such file in the directory*/
+		return ENOENT;
+		}
+
+	/*Try to lookup the given file in the underlying directory*/
+	mach_port_t p = file_name_lookup_under(dir->nn->port, name, 0, 0);
+	
+	/*If the lookup failed*/
+	if(p == MACH_PORT_NULL)
+		{
+		/*unlock the directory*/
+		mutex_unlock(&dir->lock);
+
+		/*no such entry*/
+		return ENOENT;
+		}
+
+	/*Obtain the stat information about the file*/
+	io_statbuf_t stat;
+	err = io_stat(p, &stat);
+	
+	/*Deallocate the obtained port*/
+	PORT_DEALLOC(p);
+
+	/*If this file is not a directory*/
+	if(err || !S_ISDIR(stat.st_mode))
+		{
+		/*do not set the port*/
+		p = MACH_PORT_NULL;
+		}
+	else
+		{
+		/*lookup the port with the right to read the contents of the directory*/
+		p = file_name_lookup_under(dir->nn->port, name, O_READ | O_DIRECTORY, 0);
+		if(p == MACH_PORT_NULL)
+			{
+			return EBADF; /*not enough rights?*/
+			}
+		}
+
+	/*The lnode corresponding to the entry we are supposed to fetch*/
+	lnode_t * lnode;
+	
+	/*Finalizes the execution of this function*/
+	void
+	finalize(void)
+		{
+		/*If some errors have occurred*/
+		if(err)
+			{
+			/*the user should receive nothing*/
+			*node = NULL;
+			
+			/*If there is some port, free it*/
+			if(p != MACH_PORT_NULL)
+				PORT_DEALLOC(p);
+			}
+		/*If there is a node to return*/
+		if(*node)
+			{
+			/*unlock the node*/
+			mutex_unlock(&(*node)->lock);
+			
+			/*add the node to the cache*/
+			ncache_node_add(*node);
+			}
+		
+		/*Unlock the mutexes in `dir`*/
+		mutex_unlock(&dir->nn->lnode->lock);
+		mutex_unlock(&dir->lock);
+		}/*finalize*/
+
+	/*Try to find an lnode called `name` under the lnode corresponding to `dir`*/
+	err = lnode_get(dir->nn->lnode, name, &lnode);
+	
+	/*If such an entry does not exist*/
+	if(err == ENOENT)
+		{
+		/*create a new lnode with the supplied name*/
+		err = lnode_create(name, &lnode);
+		if(err)
+			{
+			finalize();
+			return err;
+			}
+		
+		/*install the new lnode into the directory*/
+		lnode_install(dir->nn->lnode, lnode);
+		}
+	
+	/*Obtain the node corresponding to this lnode*/
+	err = ncache_node_lookup(lnode, node);
+	
+	/*Remove an extra reference from the lnode*/
+	lnode_ref_remove(lnode);
+	
+	/*If the lookup in the cache failed*/
+	if(err)
+		{
+		/*stop*/
+		finalize();
+		return err;
+		}
+
+	/*Store the port in the node*/
+	(*node)->nn->port = p;
+
+	/*Construct the full path to the node*/
+	err = lnode_path_construct(lnode, NULL);
+	if(err)
+		{
+		finalize();
+		return err;
+		}
+	
+	/*Now the node is up-to-date*/
+	(*node)->nn->flags = FLAG_NODE_ULFS_UPTODATE;
+
+	/*Return the result of performing the operations*/
+	finalize();
+	return err;
+	}/*netfs_attempt_lookup*/
+/*----------------------------------------------------------------------------*/
+/*Deletes `name` in `dir` for `user`*/
+error_t
+netfs_attempt_unlink
+	(
+	struct iouser * user,
+	struct node * dir,
+	char * name
+	)
+	{
+	LOG_MSG("netfs_attempt_unlink");
+
+	return 0;
+	}/*netfs_attempt_unlink*/
+/*----------------------------------------------------------------------------*/
+/*Attempts to rename `fromdir`/`fromname` to `todir`/`toname`*/
+error_t
+netfs_attempt_rename
+	(
+	struct iouser * user,
+	struct node * fromdir,
+	char * fromname,
+	struct node * todir,
+	char * toname,
+	int excl
+	)
+	{
+	LOG_MSG("netfs_attempt_rename");
+
+	/*Operation not supported*/
+	return EOPNOTSUPP;
+	}/*netfs_attempt_rename*/
+/*----------------------------------------------------------------------------*/
+/*Attempts to create a new directory*/
+error_t
+netfs_attempt_mkdir
+	(
+	struct iouser * user,
+	struct node * dir,
+	char * name,
+	mode_t mode
+	)
+	{
+	LOG_MSG("netfs_attempt_mkdir");
+
+	return 0;
+	}/*netfs_attempt_mkdir*/
+/*----------------------------------------------------------------------------*/
+/*Attempts to remove directory `name` in `dir` for `user`*/
+error_t
+netfs_attempt_rmdir
+	(
+	struct iouser * user,
+	struct node * dir,
+	char * name
+	)
+	{
+	LOG_MSG("netfs_attempt_rmdir");
+
+	return 0;
+	}/*netfs_attempt_rmdir*/
+/*----------------------------------------------------------------------------*/
+/*Attempts to change the mode of `node` for user `cred` to `uid`:`gid`*/
+error_t
+netfs_attempt_chown
+	(
+	struct iouser * cred,
+	struct node * node,
+	uid_t uid,
+	uid_t gid
+	)
+	{
+	LOG_MSG("netfs_attempt_chown");
+
+	/*Operation is not supported*/
+	return EOPNOTSUPP;
+	}/*netfs_attempt_chown*/
+/*----------------------------------------------------------------------------*/
+/*Attempts to change the author of `node` to `author`*/
+error_t
+netfs_attempt_chauthor
+	(
+	struct iouser * cred,
+	struct node * node,
+	uid_t author
+	)
+	{
+	LOG_MSG("netfs_attempt_chauthor");
+
+	/*Operation is not supported*/
+	return EOPNOTSUPP;
+	}/*netfs_attempt_chauthor*/
+/*----------------------------------------------------------------------------*/
+/*Attempts to change the mode of `node` to `mode` for `cred`*/
+error_t
+netfs_attempt_chmod
+	(
+	struct iouser * user,
+	struct node * node,
+	mode_t mode
+	)
+	{
+	LOG_MSG("netfs_attempt_chmod");
+
+	/*Operation is not supported*/
+	return EOPNOTSUPP;
+	}/*netfs_attempt_chmod*/
+/*----------------------------------------------------------------------------*/
+/*Attempts to turn `node` into a symlink targetting `name`*/
+error_t
+netfs_attempt_mksymlink
+	(
+	struct iouser * cred,
+	struct node * node,
+	char * name
+	)
+	{
+	LOG_MSG("netfs_attempt_mksymlink");
+
+	/*Operation is not supported*/
+	return EOPNOTSUPP;
+	}/*netfs_attempt_mksymlink*/
+/*----------------------------------------------------------------------------*/
+/*Attempts to turn `node` into a device; type can be either S_IFBLK or S_IFCHR*/
+error_t
+netfs_attempt_mkdev
+	(
+	struct iouser * cred,
+	struct node * node,
+	mode_t type,
+	dev_t indexes
+	)
+	{
+	LOG_MSG("netfs_attempt_mkdev");
+
+	/*Operation is not supported*/
+	return EOPNOTSUPP;
+	}/*netfs_attempt_mkdev*/
+/*----------------------------------------------------------------------------*/
+/*Attempts to set the passive translator record for `file` passing `argz`*/
+error_t
+netfs_set_translator
+	(
+	struct iouser * cred,
+	struct node * node,
+	char * argz,
+	size_t arglen
+	)
+	{
+	LOG_MSG("netfs_set_translator");
+
+	/*Operation is not supported*/
+	return EOPNOTSUPP;
+	}/*netfs_set_translator	*/
+/*----------------------------------------------------------------------------*/
+/*Attempts to call chflags for `node`*/
+error_t
+netfs_attempt_chflags
+	(
+	struct iouser * cred,
+	struct node * node,
+	int flags
+	)
+	{
+	LOG_MSG("netfs_attempt_chflags");
+
+	/*Operation is not supported*/
+	return EOPNOTSUPP;
+	}/*netfs_attempt_chflags*/
+/*----------------------------------------------------------------------------*/
+/*Attempts to set the size of file `node`*/
+error_t
+netfs_attempt_set_size
+	(
+	struct iouser * cred,
+	struct node * node,
+	loff_t size
+	)
+	{
+	LOG_MSG("netfs_attempt_set_size");
+
+	/*Operation is not supported*/
+	return EOPNOTSUPP;
+	}/*netfs_attempt_set_size*/
+/*----------------------------------------------------------------------------*/
+/*Fetches the filesystem status information*/
+error_t
+netfs_attempt_statfs
+	(
+	struct iouser * cred,
+	struct node * node,
+	fsys_statfsbuf_t * st
+	)
+	{
+	LOG_MSG("netfs_attempt_statfs");
+
+	/*Operation is not supported*/
+	return EOPNOTSUPP;
+	}/*netfs_attempt_statfs*/
+/*----------------------------------------------------------------------------*/
+/*Syncs the filesystem*/
+error_t
+netfs_attempt_syncfs
+	(
+	struct iouser * cred,
+	int wait
+	)
+	{
+	LOG_MSG("netfs_attempt_syncfs");
+
+	/*Everythin OK*/
+	return 0;
+	}/*netfs_attempt_syncfs*/
+/*----------------------------------------------------------------------------*/
+/*Creates a link in `dir` with `name` to `file`*/
+error_t
+netfs_attempt_link
+	(
+	struct iouser * user,
+	struct node * dir,
+	struct node * file,
+	char * name,
+	int excl
+	)
+	{
+	LOG_MSG("netfs_attempt_link");
+
+	/*Operation not supported*/
+	return EOPNOTSUPP;
+	}/*netfs_attempt_link*/
+/*----------------------------------------------------------------------------*/
+/*Attempts to create an anonymous file related to `dir` with `mode`*/
+error_t
+netfs_attempt_mkfile
+	(
+	struct iouser * user,
+	struct node * dir,
+	mode_t mode,
+	struct node ** node
+	)
+	{
+	LOG_MSG("netfs_attempt_mkfile");
+
+	/*Unlock the directory*/
+	mutex_unlock(&dir->lock);
+
+	/*Operation not supported*/
+	return EOPNOTSUPP;
+	}/*netfs_attempt_mkfile*/
+/*----------------------------------------------------------------------------*/
+/*Reads the contents of symlink `node` into `buf`*/
+error_t
+netfs_attempt_readlink
+	(
+	struct iouser * user,
+	struct node * node,
+	char * buf
+	)
+	{
+	LOG_MSG("netfs_attempt_readlink");
+
+	/*Operation not supported (why?..)*/
+	return EOPNOTSUPP;
+	}/*netfs_attempt_readlink*/
+/*----------------------------------------------------------------------------*/
+/*Reads from file `node` up to `len` bytes from `offset` into `data`*/
+error_t
+netfs_attempt_read
+	(
+	struct iouser * cred,
+	struct node * np,
+	loff_t offset,
+	size_t * len,
+	void * data
+	)
+	{
+	LOG_MSG("netfs_attempt_read");
+
+	error_t err = 0;
+
+	/*If there is no port open for the current node*/
+	if(np->nn->port == MACH_PORT_NULL)
+		{
+		/*the parent node of the current node*/
+		node_t * dnp;
+
+		/*obtain the parent node of the the current node*/
+		err = ncache_node_lookup(np->nn->lnode->dir, &dnp);
+		
+		/*the lookup should never fail here*/
+		assert(!err);
+		
+		/*open a port to the file we are interested in*/
+		mach_port_t p = file_name_lookup_under
+			(dnp->nn->port, np->nn->lnode->name, O_READ, 0);
+
+		/*put `dnp` back, since we don't need it any more*/
+		netfs_nput(dnp);
+
+		if(!p)
+			return EBADF;
+			
+		/*store the port in the node*/
+		np->nn->port = p;
+		}
+		
+	/*Read the required data from the file*/
+	err = io_read(np->nn->port, (char **)&data, len, offset, *len);
+
+	/*Return the result of reading*/
+	return err;
+	}/*netfs_attempt_read*/
+/*----------------------------------------------------------------------------*/
+/*Writes to file `node` up to `len` bytes from offset from `data`*/
+error_t
+netfs_attempt_write
+	(
+	struct iouser * cred,
+	struct node * node,
+	loff_t offset,
+	size_t * len,
+	void * data
+	)
+	{
+	LOG_MSG("netfs_attempt_write");
+
+	return 0;
+	}/*netfs_attempt_write*/
+/*----------------------------------------------------------------------------*/
+/*Frees all storage associated with the node*/
+void
+netfs_node_norefs
+	(
+	struct node * np
+	)
+	{
+	/*Destroy the node*/
+	node_destroy(np);
+	}/*netfs_node_norefs*/
+/*----------------------------------------------------------------------------*/
+/*Entry point*/
+int
+main
+	(
+	int argc,
+	char ** argv
+	)
+	{
+	/*Start logging*/
+	INIT_LOG();
+	LOG_MSG(">> Starting initialization...");
+
+	/*The port on which this translator will be set upon*/
+	mach_port_t bootstrap_port;
+	
+	error_t err = 0;
+	
+	/*Parse the command line arguments*/
+	argp_parse(&argp_startup, argc, argv, ARGP_IN_ORDER, 0, 0);
+	LOG_MSG("Command line arguments parsed.");
+	
+	/*Try to create the root node*/
+	err = node_create_root(&netfs_root_node);
+	if(err)
+		error(EXIT_FAILURE, err, "Failed to create the root node");
+	LOG_MSG("Root node created.");
+
+	/*Obtain the bootstrap port*/
+	task_get_bootstrap_port(mach_task_self(), &bootstrap_port);
+
+	/*Initialize the translator*/
+	netfs_init();
+
+	/*Obtain a port to the underlying node*/
+	underlying_node = netfs_startup(bootstrap_port, O_READ);
+	LOG_MSG("netfs initialization complete.");
+
+	/*Initialize the root node*/
+	err = node_init_root(netfs_root_node);
+	if(err)
+		error(EXIT_FAILURE, err, "Failed to initialize the root node");
+	LOG_MSG("Root node initialized.");
+	LOG_MSG("\tRoot node address: 0x%lX", (unsigned long)netfs_root_node);
+	
+	/*Map the time for updating node information*/
+	err = maptime_map(0, 0, &maptime);
+	if(err)
+		error(EXIT_FAILURE, err, "Failed to map the time");
+	LOG_MSG("Time mapped.");
+		
+	/*Initialize the cache with the required number of nodes*/
+	ncache_init(ncache_size);
+	LOG_MSG("Cache initialized.");
+	
+	/*Obtain stat information about the underlying node*/
+	err = io_stat(underlying_node, &underlying_node_stat);
+	if(err)
+		error(EXIT_FAILURE, err,
+			"Cannot obtain stat information about the underlying node");
+	LOG_MSG("Stat information for undelying node obtained.");
+		
+	/*Obtain the ID of the current process*/
+	fsid = getpid();
+
+	/*Setup the stat information for the root node*/
+	netfs_root_node->nn_stat = underlying_node_stat;
+
+	netfs_root_node->nn_stat.st_ino 	= FILTERFS_ROOT_INODE;
+	netfs_root_node->nn_stat.st_fsid	= fsid;
+	netfs_root_node->nn_stat.st_mode = S_IFDIR | (underlying_node_stat.st_mode
+		& ~S_IFMT & ~S_ITRANS); /*we are providing a translated directory*/
+		
+	netfs_root_node->nn_translated = netfs_root_node->nn_stat.st_mode;
+	
+	/*If the underlying node is not a directory, enhance the permissions
+		of the root node of filterfs*/
+	if(!S_ISDIR(underlying_node_stat.st_mode))
+		{
+		/*can be read by owner*/
+		if(underlying_node_stat.st_mode & S_IRUSR)
+			/*allow execution by the owner*/
+			netfs_root_node->nn_stat.st_mode |= S_IXUSR;
+		/*can be read by group*/
+		if(underlying_node_stat.st_mode & S_IRGRP)
+			/*allow execution by the group*/
+			netfs_root_node->nn_stat.st_mode |= S_IXGRP;
+		/*can be read by others*/
+		if(underlying_node_stat.st_mode & S_IROTH)
+			/*allow execution by the others*/
+			netfs_root_node->nn_stat.st_mode |= S_IXOTH;
+		}
+		
+	/*Update the timestamps of the root node*/
+	fshelp_touch
+		(&netfs_root_node->nn_stat, TOUCH_ATIME | TOUCH_MTIME | TOUCH_CTIME,
+		maptime);
+
+	LOG_MSG(">> Initialization complete. Entering netfs server loop...");
+	
+	/*Start serving clients*/
+	for(;;)
+		netfs_server_loop();
+	}/*main*/
+/*----------------------------------------------------------------------------*/
diff --git a/netfs-sample/filterfs.h b/netfs-sample/filterfs.h
new file mode 100644
index 00000000..4470a7fb
--- /dev/null
+++ b/netfs-sample/filterfs.h
@@ -0,0 +1,453 @@
+/*----------------------------------------------------------------------------*/
+/*filter.h*/
+/*----------------------------------------------------------------------------*/
+/*The definitions for the filtering translator*/
+/*----------------------------------------------------------------------------*/
+/*Based on the code of unionfs translator.*/
+/*----------------------------------------------------------------------------*/
+/*Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
+  Written by Sergiu Ivanov <unlimitedscolobb@gmail.com>.
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or * (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.*/
+/*----------------------------------------------------------------------------*/
+#ifndef __FILTERFS_H__
+#define __FILTERFS_H__
+/*----------------------------------------------------------------------------*/
+#include <stddef.h>
+#include <stdlib.h>
+#include <cthreads.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/statfs.h>
+#include <sys/time.h>
+#include <hurd/ihash.h>
+#include <hurd/iohelp.h>
+/*----------------------------------------------------------------------------*/
+#include "lib.h"
+#include "node.h"
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Macros--------------------------------------------------------------*/
+/*The inode for the root node*/
+#define FILTERFS_ROOT_INODE 1
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Global Variables----------------------------------------------------*/
+/*A mapped time value for filterfs*/
+/*Required for a very fast access to time*/
+extern volatile struct mapped_time_value * maptime;
+/*----------------------------------------------------------------------------*/
+/*A port to the underlying node*/
+extern mach_port_t underlying_node;
+/*----------------------------------------------------------------------------*/
+/*The stat information about the underlying node*/
+extern io_statbuf_t underlying_node_stat;
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Structures----------------------------------------------------------*/
+/*A single entry in a directory*/
+struct filterfs_dir_entry
+	{
+	char * name;	/*name of the entry*/
+	size_t hv;		/*hash value of NAME*/
+	
+	struct node * node; /*the active node referred to by this node (may be 0)*/
+											/*NETFS_NDOE_REFCNT_LOCK should be hel whule frobbing this*/
+
+	struct stat stat; /*status information*/
+
+	char * symlink_target; /*the name of the node this entry might refer to*/
+	
+	time_t stat_timestamp; /*the moment at which the status information was retreieved*/
+	
+  /*the directory to which this entry belongs*/
+	struct filterfs_dir * dir;
+	
+	/*link to the entry in hash bucket and the address of the previous entry's
+	(or hashtable's) pointer to this entry*/
+	/*If self_p is null, then this entry is deleted and awaiting
+	the final disposal*/
+	struct filterfs_dir_entry * next, ** self_p;
+	
+	/*the next and the previous entries in the 'directory order'; 0 if there
+	are none*/
+	struct filterfs_dir_entry * ordered_next, ** ordered_self_p;
+	
+	/*when the presence/absence of this file was last checked*/
+	time_t name_timestamp;
+	
+	/*used for removing this entry*/
+	hurd_ihash_locp_t inode_locp;
+	
+	/*a field for a negative result of lookup*/
+	int noent : 1;
+	
+	/*a marker for gabage collecting*/
+	int valid : 1;
+	};/*struct filterfs_dir_entry*/
+/*----------------------------------------------------------------------------*/
+/*A directory*/
+struct filterfs_dir
+	{
+	/*the number of entries in the hash table*/
+	size_t num_entries;
+	
+	/*the number of entries that have nodes attached*/
+	/*We keep an additional reference to our node if there is any,
+		to prevent it from going away*/
+	size_t num_live_entries;
+	
+	/*the hash table for entries*/
+	struct filterfs_dir_entry ** htable;
+	size_t htable_len; /*the lenght of the hash table*/
+	
+	/*the list of entries in 'directory order'.*/
+	/*The entries are listed in a linked list using the ordered_next
+		and ordered_self_p fields in each entry. Not all entries in htable
+		need to be in this list*/
+	struct filterfs_dir_entry * ordered;
+	
+	/*the filesystem node corresponding to this directory*/
+	struct node * node;
+	
+	/*the filesystem this directory is in*/
+	struct filterfs * fs;
+
+	/*when the presence/absence of this file was last checked*/
+	time_t name_timestamp;
+	
+	/*used for removing this entry*/
+	hurd_ihash_locp_t inode_locp;
+	
+	/*Stuff for detecting bulk stats (?)*/
+	/*Might be reduntant for this project*/
+
+	/*the timestamp of the first sample in bulk_stat_count1, rounded to
+		BULK_STAT_PERIOD seconds*/
+	time_t buld_stat_base_stamp;
+	
+	/*the number of stats done in the period
+	[bulk_stat_base_stamp, bulk_stat_base_stamp + BULK_STAT_PERIOD]*/
+	unsigned bulk_stat_count_first_half;
+	
+	/*the number of stats done in the period
+	[bulk_stat_bast_stamp + BULK_STAT_PERIOD,
+		bulk_stat_bast_stamp + 2 * BULK_STAT_PERIOD]*/
+	unsigned bulk_stat_count_second_half;
+	};/*struct filterfs_dir*/
+/*----------------------------------------------------------------------------*/
+/*A particular filesystem*/
+struct filterfs
+	{
+	/*the root of the filesystem*/
+	struct node * root;
+	
+	/*inode numbers*/
+	/*Assigned sequentially in the order of creation*/
+	ino_t next_inode;
+	
+	/*the identifier of the filesystem (?)*/
+	int fsid;
+	
+	/*a hash table mapping inode numbers to directory entries*/
+	struct hurd_ihash inode_mappings;
+	
+	/*the lock for the hash table*/
+	spin_lock_t inode_mappings_lock;
+	};/*struct filterfs*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Functions-----------------------------------------------------------*/
+/*Attempts to create a file named `name` in `dir` for `user` with mode `mode`*/
+error_t
+netfs_attempt_create_file
+	(
+	struct iouser * user,
+	struct node * dir,
+	char * name,
+	mode_t mode,
+	struct node ** node
+	);
+/*----------------------------------------------------------------------------*/
+/*Returns an error if the process of opening a file should not be allowed
+	to complete because of insufficient permissions*/
+error_t
+netfs_check_open_permissions
+	(
+	struct iouser * user,
+	struct node * np,
+	int flags,
+	int newnode
+	);
+/*----------------------------------------------------------------------------*/
+/*Attempts an utimes call for the user `cred` on node `node`*/
+error_t
+netfs_attempt_utimes
+	(
+	struct iouser * cred,
+	struct node * node,
+	struct timespec * atime,
+	struct timespec * mtime
+	);
+/*----------------------------------------------------------------------------*/
+/*Returns the valid access types for file `node` and user `cred`*/
+error_t
+netfs_report_access
+	(
+	struct iouser * cred,
+	struct node * np,
+	int * types
+	);
+/*----------------------------------------------------------------------------*/
+/*Validates the stat data for the node*/
+error_t
+netfs_validate_stat
+	(
+	struct node * np,
+	struct iouser * cred
+	);
+/*----------------------------------------------------------------------------*/
+/*Syncs `node` completely to disk*/
+error_t
+netfs_attempt_sync
+	(
+	struct iouser * cred,
+	struct node * node,
+	int wait
+	);
+/*----------------------------------------------------------------------------*/
+/*Fetches a directory*/
+error_t
+netfs_get_dirents
+	(
+	struct iouser * cred,
+	struct node * dir,
+	int first_entry,
+	int num_entries,
+	char ** data,
+	mach_msg_type_number_t * data_len,
+	vm_size_t max_data_len,
+	int * data_entries
+	);
+/*----------------------------------------------------------------------------*/
+/*Looks up `name` under `dir` for `user`*/
+error_t
+netfs_attempt_lookup
+	(
+	struct iouser * user,
+	struct node * dir,
+	char * name,
+	struct node ** node
+	);
+/*----------------------------------------------------------------------------*/
+/*Deletes `name` in `dir` for `user`*/
+error_t
+netfs_attempt_unlink
+	(
+	struct iouser * user,
+	struct node * dir,
+	char * name
+	);
+/*----------------------------------------------------------------------------*/
+/*Attempts to rename `fromdir`/`fromname` to `todir`/`toname`*/
+error_t
+netfs_attempt_rename
+	(
+	struct iouser * user,
+	struct node * fromdir,
+	char * fromname,
+	struct node * todir,
+	char * toname,
+	int excl
+	);
+/*----------------------------------------------------------------------------*/
+/*Attempts to create a new directory*/
+error_t
+netfs_attempt_mkdir
+	(
+	struct iouser * user,
+	struct node * dir,
+	char * name,
+	mode_t mode
+	);
+/*----------------------------------------------------------------------------*/
+/*Attempts to remove directory `name` in `dir` for `user`*/
+error_t
+netfs_attempt_rmdir
+	(
+	struct iouser * user,
+	struct node * dir,
+	char * name
+	);
+/*----------------------------------------------------------------------------*/
+/*Attempts to change the owner of `node` for user `cred` to `uid`:`gid`*/
+error_t
+netfs_attempt_chown
+	(
+	struct iouser * cred,
+	struct node * node,
+	uid_t uid,
+	uid_t gid
+	);
+/*----------------------------------------------------------------------------*/
+/*Attempts to change the author of `node` to `author`*/
+error_t
+netfs_attempt_chauthor
+	(
+	struct iouser * cred,
+	struct node * node,
+	uid_t author
+	);
+/*----------------------------------------------------------------------------*/
+/*Attempts to change the mode of `node` to `mode` for `cred`*/
+error_t
+netfs_attempt_chmod
+	(
+	struct iouser * user,
+	struct node * node,
+	mode_t mode
+	);
+/*----------------------------------------------------------------------------*/
+/*Attempts to turn `node` into a symlink targetting `name`*/
+error_t
+netfs_attempt_mksymlink
+	(
+	struct iouser * cred,
+	struct node * node,
+	char * name
+	);
+/*----------------------------------------------------------------------------*/
+/*Attempts to turn `node` into a device; type can be either S_IFBLK or S_IFCHR*/
+error_t
+netfs_attempt_mkdev
+	(
+	struct iouser * cred,
+	struct node * node,
+	mode_t type,
+	dev_t indexes
+	);
+/*----------------------------------------------------------------------------*/
+/*Attempts to set the passive translator record for `file` passing `argz`*/
+error_t
+netfs_set_translator
+	(
+	struct iouser * cred,
+	struct node * node,
+	char * argz,
+	size_t arglen
+	);
+/*----------------------------------------------------------------------------*/
+/*Attempts to call chflags for `node`*/
+error_t
+netfs_attempt_chflags
+	(
+	struct iouser * cred,
+	struct node * node,
+	int flags
+	);
+/*----------------------------------------------------------------------------*/
+/*Attempts to set the size of file `node`*/
+error_t
+netfs_attempt_set_size
+	(
+	struct iouser * cred,
+	struct node * node,
+	loff_t size
+	);
+/*----------------------------------------------------------------------------*/
+/*Fetches the filesystem status information*/
+error_t
+netfs_attempt_statfs
+	(
+	struct iouser * cred,
+	struct node * node,
+	fsys_statfsbuf_t * st
+	);
+/*----------------------------------------------------------------------------*/
+/*Syncs the filesystem*/
+error_t
+netfs_attempt_syncfs
+	(
+	struct iouser * cred,
+	int wait
+	);
+/*----------------------------------------------------------------------------*/
+/*Creates a link in `dir` with `name` to `file`*/
+error_t
+netfs_attempt_link
+	(
+	struct iouser * user,
+	struct node * dir,
+	struct node * file,
+	char * name,
+	int excl
+	);
+/*----------------------------------------------------------------------------*/
+/*Attempts to create an anonymous file related to `dir` with `mode`*/
+error_t
+netfs_attempt_mkfile
+	(
+	struct iouser * user,
+	struct node * dir,
+	mode_t mode,
+	struct node ** node
+	);
+/*----------------------------------------------------------------------------*/
+/*Reads the contents of symlink `node` into `buf`*/
+error_t
+netfs_attempt_readlink
+	(
+	struct iouser * user,
+	struct node * node,
+	char * buf
+	);
+/*----------------------------------------------------------------------------*/
+/*Reads from file `node` up to `len` bytes from `offset` into `data`*/
+error_t
+netfs_attempt_read
+	(
+	struct iouser * cred,
+	struct node * np,
+	loff_t offset,
+	size_t * len,
+	void * data
+	);
+/*----------------------------------------------------------------------------*/
+/*Writes to file `node` up to `len` bytes from offset from `data`*/
+error_t
+netfs_attempt_write
+	(
+	struct iouser * cred,
+	struct node * node,
+	loff_t offset,
+	size_t * len,
+	void * data
+	);
+/*----------------------------------------------------------------------------*/
+/*Frees all storage associated with the node*/
+void
+netfs_node_norefs
+	(
+	struct node * np
+	);
+/*----------------------------------------------------------------------------*/
+#endif
diff --git a/netfs-sample/lib.c b/netfs-sample/lib.c
new file mode 100644
index 00000000..aa0ff0be
--- /dev/null
+++ b/netfs-sample/lib.c
@@ -0,0 +1,193 @@
+/*----------------------------------------------------------------------------*/
+/*lib.h*/
+/*----------------------------------------------------------------------------*/
+/*Basic routines for filesystem manipulations*/
+/*----------------------------------------------------------------------------*/
+/*Based on the code of unionfs translator.*/
+/*----------------------------------------------------------------------------*/
+/*Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
+  Written by Sergiu Ivanov <unlimitedscolobb@gmail.com>.
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or * (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+#define _GNU_SOURCE 1
+/*----------------------------------------------------------------------------*/
+#include <sys/mman.h>
+/*----------------------------------------------------------------------------*/
+#include "lib.h"
+#include "debug.h"
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Functions-----------------------------------------------------------*/
+/*Fetches directory entries for `dir`*/
+error_t
+dir_entries_get
+	(
+	file_t dir,
+	char ** dirent_data,					/*the list of directory entries as returned
+																	by dir_readdir*/
+	size_t * dirent_data_size,		/*the size of `dirent_data`*/
+	struct dirent *** dirent_list /*the array of pointers to beginnings of
+																	dirents in dirent_data*/
+	)
+	{
+	error_t err = 0;
+	
+	/*The data (array of dirents(?)) returned by dir_readdir*/
+	char * data;
+	
+	/*The size of `data`*/
+	size_t data_size;
+	
+	/*The number of entries in `data`*/
+	int entries_num;
+	
+	/*Try to read the contents of the specified directory*/
+	err = dir_readdir(dir, &data, &data_size, 0, -1, 0, &entries_num);
+	if(err)
+		return err;
+		
+	/*Create a new list of dirents*/
+	struct dirent ** list;
+	
+	/*Allocate the memory for the list of dirents and for the
+		finalizing element*/
+	list = malloc(sizeof(struct dirent *) * (entries_num + 1));
+	
+	/*If memory allocation has failed*/
+	if(!list)
+		{
+		/*free the result of dir_readdir*/
+		munmap(data, data_size);
+		
+		/*return the corresponding error*/
+		return ENOMEM;
+		}
+		
+	/*The current directory entry*/
+	struct dirent * dp;
+
+	int i;
+	
+	/*Go through every element of the list of dirents*/
+	for
+		(
+		i = 0, dp = (struct dirent *)data;
+		i < entries_num;
+		++i, dp = (struct dirent *)((char *)dp + dp->d_reclen))
+		/*copy the current value into the list*/
+		*(list + i) = dp;
+	
+	/*Nullify the last element of the list*/
+	*(list + i) = NULL;
+	
+	/*Copy the required values in the parameters*/
+	*dirent_data 			= data;
+	*dirent_data_size	= data_size;
+	*dirent_list 			= list;
+	
+	/*Return success*/
+	return err;
+	}/*dir_entries_get*/
+/*----------------------------------------------------------------------------*/
+/*Lookup `name` under `dir` (or cwd, if `dir` is invalid)*/
+error_t
+file_lookup
+	(
+	file_t dir,
+	char * name,
+	int flags0,					/*try to open with these flags first*/
+	int flags1,					/*try to open with these flags, if `flags0` fail*/
+	int mode,						/*if the file is to be created, create it with this mode*/
+	file_t * port,			/*store the port to the looked up file here*/
+	io_statbuf_t * stat	/*store the stat information here*/
+	)
+	{
+	error_t err = 0;
+	
+	/*The port to the looked up file*/
+	file_t p;
+	
+	/*The stat information about the looked up file*/
+	io_statbuf_t s;
+	
+	/*Performs a lookup under 'dir' or in cwd, if `dir` is invalid*/
+	file_t
+	do_file_lookup
+		(
+		file_t dir,
+		char * name,	/*lookup this file*/
+		int flags,		/*lookup the file with these flags*/
+		int mode			/*if a new file is to be created, create it with this mode*/
+		)
+		{
+		/*The result of lookup*/
+		file_t p;
+	
+		/*If `dir` is a valid port*/
+		if(dir != MACH_PORT_NULL)
+			/*try to lookup `name` under `dir`*/
+			p = file_name_lookup_under(dir, name, flags, mode);
+		else
+			/*lookup `name` under current cwd*/
+			p = file_name_lookup(name, flags, mode);
+		
+		/*Return the result of the lookup*/
+		return p;
+		}/*do_file_lookup*/
+		
+	/*Lookup `name` under the suggested `dir`*/
+	p = do_file_lookup(dir, name, flags0, mode);
+	
+	/*If the lookup failed*/
+	if(p == MACH_PORT_NULL)
+		/*try to lookup for `name` using alternative flags `flags1`*/
+		p = do_file_lookup(dir, name, flags1, mode);
+	
+	/*If the port is valid*/
+	if(p != MACH_PORT_NULL)
+		{
+		/*If stat information is required*/
+		if(stat)
+			{
+			/*obtain stat information for `p`*/
+			err = io_stat(p, &s);
+			if(err)
+				PORT_DEALLOC(p);
+			}
+		}
+	else
+		/*copy `errno` into `err`*/
+		err = errno;
+
+	/*If no errors have happened during lookup*/
+	if(!err)
+		{
+		/*copy the resulting port into *`port`*/
+		*port = p;
+		
+		/*fill in the receiver for stat information, if requried*/
+		if(stat)
+			*stat = s;
+		}
+	
+	/*Return the result of performing operations*/
+	return err;
+	}/*file_lookup*/
+/*----------------------------------------------------------------------------*/
diff --git a/netfs-sample/lib.h b/netfs-sample/lib.h
new file mode 100644
index 00000000..6335efcf
--- /dev/null
+++ b/netfs-sample/lib.h
@@ -0,0 +1,82 @@
+/*----------------------------------------------------------------------------*/
+/*lib.h*/
+/*----------------------------------------------------------------------------*/
+/*Declarations of basic routines for filesystem manipulations*/
+/*----------------------------------------------------------------------------*/
+/*Based on the code of unionfs translator.*/
+/*----------------------------------------------------------------------------*/
+/*Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
+  Written by Sergiu Ivanov <unlimitedscolobb@gmail.com>.
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or * (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.*/
+/*----------------------------------------------------------------------------*/
+#ifndef __LIB_H__
+#define __LIB_H__
+
+/*----------------------------------------------------------------------------*/
+#define __USE_FILE_OFFSET64
+/*----------------------------------------------------------------------------*/
+#include <hurd.h>
+#include <dirent.h>
+#include <stddef.h>
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Macros--------------------------------------------------------------*/
+/*Alignment of directory entries*/
+#define DIRENT_ALIGN 4
+/*----------------------------------------------------------------------------*/
+/*The offset of the directory name in the directory entry structure*/
+#define DIRENT_NAME_OFFS offsetof(struct dirent, d_name)
+/*----------------------------------------------------------------------------*/
+/*Computes the length of the structure before the name + the name + 0,
+	all padded to DIRENT_ALIGN*/
+#define DIRENT_LEN(name_len)\
+	((DIRENT_NAME_OFFS + (name_len) + 1 + DIRENT_ALIGN - 1) &\
+	~(DIRENT_ALIGN - 1))
+/*----------------------------------------------------------------------------*/
+/*Deallocate the given port for the current task*/
+#define PORT_DEALLOC(p) (mach_port_deallocate(mach_task_self(), (p)))
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Functions-----------------------------------------------------------*/
+/*Fetches directory entries for `dir`*/
+error_t
+dir_entries_get
+	(
+	file_t dir,
+	char ** dirent_data,					/*the list of directory entries as returned
+																	by dir_readdir*/
+	size_t * dirent_data_size,		/*the size of `dirent_data`*/
+	struct dirent *** dirent_list /*the array of pointers to beginnings of
+																	dirents in dirent_data*/
+	);
+/*----------------------------------------------------------------------------*/
+/*Lookup `name` under `dir` (or cwd, if `dir` is invalid)*/
+error_t
+file_lookup
+	(
+	file_t dir,
+	char * name,
+	int flags0,					/*try to open with these flags first*/
+	int flags1,					/*try to open with these flags, if `flags0` fail*/
+	int mode,						/*if the file is to be created, create it with this mode*/
+	file_t * port,			/*store the port to the looked up file here*/
+	io_statbuf_t * stat	/*store the stat information here*/
+	);
+/*----------------------------------------------------------------------------*/
+#endif /*__LIB_H__*/
diff --git a/netfs-sample/lnode.c b/netfs-sample/lnode.c
new file mode 100644
index 00000000..33394ed0
--- /dev/null
+++ b/netfs-sample/lnode.c
@@ -0,0 +1,305 @@
+/*----------------------------------------------------------------------------*/
+/*lnode.c*/
+/*----------------------------------------------------------------------------*/
+/*Implementation of policies of management of 'light nodes'*/
+/*----------------------------------------------------------------------------*/
+/*Based on the code of unionfs translator.*/
+/*----------------------------------------------------------------------------*/
+/*Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
+  Written by Sergiu Ivanov <unlimitedscolobb@gmail.com>.
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or * (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+#define _GNU_SOURCE
+/*----------------------------------------------------------------------------*/
+#include "lnode.h"
+#include "debug.h"
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Functions-----------------------------------------------------------*/
+/*Adds a reference to the `lnode` (which must be locked)*/
+void
+lnode_ref_add
+	(
+	lnode_t * node
+	)
+	{
+	/*Increment the number of references*/
+	++node->references;
+	}/*lnode_ref_add*/
+/*----------------------------------------------------------------------------*/
+/*Removes a reference from `node` (which must be locked). If that was the last
+	reference, destroy the node*/
+void
+lnode_ref_remove
+	(
+	lnode_t * node
+	)
+	{
+	/*Fail if the node is not referenced by anybody*/
+	assert(node->references);
+	
+	/*Decrement the number of references to `node`*/
+	--node->references;
+	
+	/*If there are no references remaining*/
+	if(node->references == 0)
+		{
+		/*uninstall the node from the directory it is in and destroy it*/
+		lnode_uninstall(node);
+		lnode_destroy(node);
+		}
+	else
+		/*simply unlock the node*/
+		mutex_unlock(&node->lock);
+	}/*lnode_ref_remove*/
+/*----------------------------------------------------------------------------*/
+/*Creates a new lnode with `name`; the new node is locked and contains
+	a single reference*/
+error_t
+lnode_create
+	(
+	char * name,
+	lnode_t ** node	/*put the result here*/
+	)
+	{
+	/*Allocate the memory for the node*/
+	lnode_t * node_new = malloc(sizeof(lnode_t));
+	
+	/*If the memory has not been allocated*/
+	if(!node_new)
+		{
+		/*stop*/
+		return ENOMEM;
+		}
+		
+	/*The copy of the name*/
+	char * name_cp = NULL;
+	
+	/*If the name exists*/
+	if(name)
+		{
+		/*duplicate it*/
+		name_cp = strdup(name);
+		
+		/*If the name has not been duplicated*/
+		if(!name_cp)
+			{
+			/*free the node*/
+			free(node_new);
+			
+			/*stop*/
+			return ENOMEM;
+			}
+		}
+		
+	/*Setup the new node*/
+	memset(node_new, 0, sizeof(lnode_t));
+	node_new->name 				= name_cp;
+	node_new->name_len		= (name_cp) ? (strlen(name_cp)) : (0);
+	
+	/*Setup one reference to this lnode*/
+	node_new->references = 1;
+	
+	/*Initialize the mutex and acquire a lock on this lnode*/
+	mutex_init(&node_new->lock);
+	mutex_lock(&node_new->lock);
+	
+	/*Store the result in the second parameter*/
+	*node = node_new;
+
+	/*Return success*/
+	return 0;
+	}/*lnode_create*/
+/*----------------------------------------------------------------------------*/
+/*Destroys the given lnode*/
+void
+lnode_destroy
+	(
+	lnode_t * node	/*destroy this*/
+	)
+	{
+	/*Destroy the name of the node*/
+	free(node->name);
+	
+	/*Destroy the node itself*/
+	free(node);
+	}/*lnode_destroy*/
+/*----------------------------------------------------------------------------*/
+/*Constructs the full path for the given lnode and stores the result both in
+	the parameter and inside the lnode (the same string, actually)*/
+error_t
+lnode_path_construct
+	(
+	lnode_t * node,
+	char ** path	/*store the path here*/
+	)
+	{
+	error_t err = 0;
+
+	/*The final path*/
+	char * p;
+	
+	/*The final length of the path*/
+	int p_len = 0;
+	
+	/*A temporary pointer to an lnode*/
+	lnode_t * n;
+	
+	/*While the root node of the filterfs filesystem has not been reached*/
+	for(n = node; n && n->dir; n = n->dir)
+		/*add the length of the name of `n` to `p_len` make some space for
+			the delimiter '/', if we are not approaching the root node*/
+		/*p_len += n->name_len + ((n->dir->dir) ? (1) : (0));*/
+		/*There is some path to our root node, so we will anyway have to
+			add a '/'*/
+		p_len += n->name_len + 1;
+		
+	/*Include the space for the path to the root node of the filterfs
+		(n is now the root of the filesystem)*/
+	p_len += strlen(n->path) + 1;
+		
+	/*Try to allocate the space for the string*/
+	p = malloc(p_len * sizeof(char));
+	if(!p)
+		err = ENOMEM;
+	/*If memory allocation has been successful*/
+	else
+		{
+		/*put a terminal 0 at the end of the path*/
+		p[--p_len] = 0;
+		
+		/*While the root node of the filterfs filesystem has not been reached*/
+		for(n = node; n && n->dir; n = n->dir)
+			{
+			/*compute the position where the name of `n` is to be inserted*/
+			p_len -= n->name_len;
+			
+			/*copy the name of the node into the path (omit the terminal 0)*/
+			strncpy(p + p_len, n->name, n->name_len);
+			
+			/*If we are not at the root node of the filterfs filesystem, add the
+				separator*/
+			/*if(n->dir->dir)
+				p[--p_len] = '/';*/
+			/*we anyway have to add the separator slash*/
+			p[--p_len] = '/';
+			}
+		
+		/*put the path to the root node at the beginning of the first path
+			(n is at the root now)*/
+		strncpy(p, n->path, strlen(n->path));
+		
+		/*destroy the former path in lnode, if it exists*/
+		if(node->path)
+			free(node->path);
+		
+		/*store the new path inside the lnode*/
+		node->path = p;
+
+		/*store the path in the parameter*/
+		if(path)
+			*path = p;
+		}
+		
+	/*Return the result of operations*/
+	return err;
+	}/*lnode_path_construct*/
+/*----------------------------------------------------------------------------*/
+/*Gets a light node by its name, locks it and increments its refcount*/
+error_t
+lnode_get
+	(
+	lnode_t * dir,	/*search here*/
+	char * name,		/*search for this name*/
+	lnode_t ** node	/*put the result here*/
+	)
+	{
+	error_t err = 0;
+	
+	/*The pointer to the required lnode*/
+	lnode_t * n;
+	
+	/*Find `name` among the names of entries in `dir`*/
+	for(n = dir->entries; n && (strcmp(n->name, name) != 0); n = n->next);
+	
+	/*If the search has been successful*/
+	if(n)
+		{
+		/*lock the node*/
+		mutex_lock(&n->lock);
+		
+		/*increment the refcount of the found lnode*/
+		lnode_ref_add(n);
+		
+		/*put a pointer to `n` into the parameter*/
+		*node = n;
+		}
+	else
+		err = ENOENT;
+		
+	/*Return the result of operations*/
+	return err;
+	}/*lnode_get*/
+/*----------------------------------------------------------------------------*/
+/*Install the lnode into the lnode tree: add a reference to `dir` (which must
+	be locked)*/
+void
+lnode_install
+	(
+	lnode_t * dir,	/*install here*/
+	lnode_t * node	/*install this*/
+	)
+	{
+	/*Install `node` into the list of entries in `dir`*/
+	node->next = dir->entries;
+	node->prevp = &dir->entries; /*this node is the first on the list*/
+	if(dir->entries)
+		dir->entries->prevp = &node->next;	/*here `prevp` gets the value
+																					corresponding to its meaning*/
+	dir->entries = node;
+	
+	/*Add a new reference to dir*/
+	lnode_ref_add(dir);
+	
+	/*Setup the `dir` link in node*/
+	node->dir = dir;
+	}/*lnode_install*/
+/*----------------------------------------------------------------------------*/
+/*Unistall the node from the node tree; remove a reference from the lnode
+	containing `node`*/
+void
+lnode_uninstall
+	(
+	lnode_t * node
+	)
+	{
+	/*Remove a reference from the parent*/
+	lnode_ref_remove(node->dir);
+	
+	/*Make the next pointer in the previous element point to the element,
+		which follows `node`*/
+	*node->prevp = node->next;
+
+	/*If the current node is not the last one, connect the list after removal
+		of the current node*/
+	if(node->next)
+		node->next->prevp = &node->next;
+	}/*lnode_uninstall*/
+/*----------------------------------------------------------------------------*/
diff --git a/netfs-sample/lnode.h b/netfs-sample/lnode.h
new file mode 100644
index 00000000..7c42c8d4
--- /dev/null
+++ b/netfs-sample/lnode.h
@@ -0,0 +1,143 @@
+/*----------------------------------------------------------------------------*/
+/*lnode.h*/
+/*----------------------------------------------------------------------------*/
+/*Management of cheap 'light nodes'*/
+/*----------------------------------------------------------------------------*/
+/*Based on the code of unionfs translator.*/
+/*----------------------------------------------------------------------------*/
+/*Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
+  Written by Sergiu Ivanov <unlimitedscolobb@gmail.com>.
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or * (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.*/
+/*----------------------------------------------------------------------------*/
+#ifndef __LNODE_H__
+#define __LNODE_H__
+
+/*----------------------------------------------------------------------------*/
+#include <error.h>
+#include <hurd/netfs.h>
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*A candy synonym for the fundamental libnetfs node*/
+typedef struct node node_t;
+/*----------------------------------------------------------------------------*/
+/*The light node*/
+struct lnode
+	{
+	/*the name of the lnode*/
+	char * name;
+	
+	/*the length of the name; `name` does not change, and this value is used
+	quite often, therefore calculate it just once*/
+	size_t name_len;
+	
+	/*the full path to the lnode*/
+	char * path;
+	
+	/*the associated flags*/
+	int flags;
+	
+	/*the number of references to this lnode*/
+	int references;
+	
+	/*the reference to the real node*/
+	node_t * node;
+	
+	/*the next lnode and the pointer to this lnode from the previous one*/
+	struct lnode * next, **prevp;
+	
+	/*the lnode (directory) in which this node is contained*/
+	struct lnode * dir;
+	
+	/*the beginning of the list of entries contained in this lnode (directory)*/
+	struct lnode * entries;
+	
+	/*a lock*/
+	struct mutex lock;
+	};/*struct lnode*/
+/*----------------------------------------------------------------------------*/
+typedef struct lnode lnode_t;
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Functions-----------------------------------------------------------*/
+/*Adds a reference to the `lnode` (which must be locked)*/
+void
+lnode_ref_add
+	(
+	lnode_t * node
+	);
+/*----------------------------------------------------------------------------*/
+/*Removes a reference from `node` (which must be locked). If that was the last
+	reference, destroy the node*/
+void
+lnode_ref_remove
+	(
+	lnode_t * node
+	);
+/*----------------------------------------------------------------------------*/
+/*Creates a new lnode with `name`; the new node is locked and contains
+	a single reference*/
+error_t
+lnode_create
+	(
+	char * name,
+	lnode_t ** node	/*put the result here*/
+	);
+/*----------------------------------------------------------------------------*/
+/*Destroys the given lnode*/
+void
+lnode_destroy
+	(
+	lnode_t * node	/*destroy this*/
+	);
+/*----------------------------------------------------------------------------*/
+/*Constructs the full path for the given lnode and stores the result both in
+	the parameter and inside the lnode (the same string, actually)*/
+error_t
+lnode_path_construct
+	(
+	lnode_t * node,
+	char ** path	/*store the path here*/
+	);
+/*----------------------------------------------------------------------------*/
+/*Gets a light node by its name, locks it and increments its refcount*/
+error_t
+lnode_get
+	(
+	lnode_t * dir,	/*search here*/
+	char * name,		/*search for this name*/
+	lnode_t ** node	/*put the result here*/
+	);
+/*----------------------------------------------------------------------------*/
+/*Install the lnode into the lnode tree: add a reference to `dir` (which must
+	be locked)*/
+void
+lnode_install
+	(
+	lnode_t * dir,	/*install here*/
+	lnode_t * node	/*install this*/
+	);
+/*----------------------------------------------------------------------------*/
+/*Unistall the node from the node tree; remove a reference from the lnode*/
+void
+lnode_uninstall
+	(
+	lnode_t * node
+	);
+/*----------------------------------------------------------------------------*/
+#endif /*__LNODE_H__*/
diff --git a/netfs-sample/ncache.c b/netfs-sample/ncache.c
new file mode 100644
index 00000000..12462d31
--- /dev/null
+++ b/netfs-sample/ncache.c
@@ -0,0 +1,221 @@
+/*----------------------------------------------------------------------------*/
+/*ncache.h*/
+/*----------------------------------------------------------------------------*/
+/*The implementation of the cache of nodes*/
+/*----------------------------------------------------------------------------*/
+/*Based on the code of unionfs translator.*/
+/*----------------------------------------------------------------------------*/
+/*Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
+  Written by Sergiu Ivanov <unlimitedscolobb@gmail.com>.
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or * (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+#define _GNU_SOURCE 1
+/*----------------------------------------------------------------------------*/
+#include "ncache.h"
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Global Variables----------------------------------------------------*/
+/*The global cache chain*/
+ncache_t ncache;
+/*----------------------------------------------------------------------------*/
+/*Cache size (may be overwritten by the user)*/
+int ncache_size = NCACHE_SIZE;
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Functions-----------------------------------------------------------*/
+/*Initializes the node cache*/
+void
+ncache_init
+	(
+	int size_max
+	)
+	{
+	/*Reset the LRU and MRU ends of the list*/
+	ncache.mru = ncache.lru = NULL;
+	
+	/*Set the maximal size according to the parameter*/
+	ncache.size_max = size_max;
+	
+	/*The cache is empty so far; remark that*/
+	ncache.size_current = 0;
+	
+	/*Init the lock*/
+	mutex_init(&ncache.lock);
+	}/*ncache_init*/
+/*----------------------------------------------------------------------------*/
+/*Looks up the lnode and stores the result in `node`; creates a new entry
+	in the cache if the lookup fails*/
+error_t
+ncache_node_lookup
+	(
+	lnode_t * lnode,	/*search for this*/
+	node_t ** node		/*put the result here*/
+	)
+	{
+	error_t err = 0;
+
+	/*Obtain the pointer to the node corresponding to `lnode`*/
+	node_t * n = lnode->node;
+
+	/*If a node has already been created for the given lnode*/
+	if(n != NULL)
+		{
+		/*count a new reference to 'n'*/
+		netfs_nref(n);
+		}
+	else
+		{
+		/*create a new node for the given lnode and store the result in `n`*/
+		err = node_create(lnode, &n);
+		}
+		
+	/*If no errors have occurred during the previous operations*/
+	if(!err)
+		{
+		/*lock the mutex in the looked up node*/
+		mutex_lock(&n->lock);
+		
+		/*store the lookup result in `node`*/
+		*node = n;
+		}
+		
+	/*Return the result of operations*/
+	return err;
+	}/*ncache_node_lookup*/
+/*----------------------------------------------------------------------------*/
+/*Removes the given node from the cache*/
+static
+void
+ncache_node_remove
+	(
+	node_t * node
+	)
+	{
+	/*Obtain the pointer to the netnode (this contains the information
+		specific of us)*/
+	struct netnode * nn = node->nn;
+	
+	/*If there exists a successor of this node in the cache chain*/
+	if(nn->ncache_next)
+		/*remove the reference in the successor*/
+		nn->ncache_next->nn->ncache_prev = nn->ncache_prev;
+	/*If there exists a predecessor of this node in the cache chain*/
+	if(nn->ncache_prev)
+		/*remove the reference in the predecessor*/
+		nn->ncache_prev->nn->ncache_next = nn->ncache_next;
+	
+	/*If the node was located at the MRU end of the list*/
+	if(ncache.mru == node)
+		/*shift the MRU end to the next node*/
+		ncache.mru = nn->ncache_next;
+	/*If the node was located at the LRU end of the list*/
+	if(ncache.lru == node)
+		/*shift the LRU end to the previous node*/
+		ncache.lru = nn->ncache_prev;
+		
+	/*Invalidate the references inside the node*/
+	nn->ncache_next = nn->ncache_prev = NULL;
+	
+	/*Count the removal of a node*/
+	--ncache.size_current;
+	}/*ncache_node_remove*/
+/*----------------------------------------------------------------------------*/
+/*Resets the node cache*/
+void
+ncache_reset(void)
+	{
+	/*The node being currently deleted*/
+	node_t * node;
+	
+	/*Acquire a lock on the cache*/
+	mutex_lock(&ncache.lock);
+	
+	/*Remove the whole cache chain*/
+	for(node = ncache.mru; node != NULL; ncache_node_remove(node), node = ncache.mru);
+
+	/*Release the lock*/
+	mutex_unlock(&ncache.lock);
+	}/*ncache_reset*/
+/*----------------------------------------------------------------------------*/
+/*Adds the given node to the cache*/
+void
+ncache_node_add
+	(
+	node_t * node	/*the node to add*/
+	)
+	{
+	/*Acquire a lock on the cache*/
+	mutex_lock(&ncache.lock);
+	
+	/*If there already are some nodes in the cache and it is enabled*/
+	if((ncache.size_max > 0) || (ncache.size_current > 0))
+		{
+		/*If the node to be added is not at the MRU end already*/
+		if(ncache.mru != node)
+			{
+			/*If the node is correctly integrated in the cache*/
+			if((node->nn->ncache_next != NULL) && (node->nn->ncache_prev != NULL))
+				/*remove the old entry*/
+				ncache_node_remove(node);
+			else
+				/*add a new reference to the node*/
+				netfs_nref(node);
+			
+			/*put the node at the MRU end of the cache chain*/
+			node->nn->ncache_next = ncache.mru;
+			node->nn->ncache_prev = NULL;
+		
+			/*setup the pointer in the old MRU end, if it exists*/
+			if(ncache.mru != NULL)
+				ncache.mru->nn->ncache_prev = node;
+			
+			/*setup the LRU end of the cache chain, if it did not exist previously*/
+			if(ncache.lru == NULL)
+				ncache.lru = node;
+			
+			/*shift the MRU end to the new node*/
+			ncache.mru = node;
+		
+			/*count the addition*/
+			++ncache.size_current;
+			}
+		}
+		
+	/*While the size of the cache is exceeding the maximal size*/
+	node_t * old_lru;
+	for
+		(
+		old_lru = ncache.lru;
+		ncache.size_current > ncache.size_max;
+		old_lru = ncache.lru
+		)
+		{
+		/*remove the current LRU end of the list from the cache*/
+		ncache_node_remove(old_lru);
+		
+		/*release the reference to the node owned by this thread*/
+		netfs_nrele(old_lru);
+		}
+		
+	/*Release the lock on the cache*/
+	mutex_unlock(&ncache.lock);
+	}/*ncache_node_add*/
+/*----------------------------------------------------------------------------*/
diff --git a/netfs-sample/ncache.h b/netfs-sample/ncache.h
new file mode 100644
index 00000000..124d514e
--- /dev/null
+++ b/netfs-sample/ncache.h
@@ -0,0 +1,100 @@
+/*----------------------------------------------------------------------------*/
+/*ncache.h*/
+/*----------------------------------------------------------------------------*/
+/*The cache of nodes*/
+/*----------------------------------------------------------------------------*/
+/*Based on the code of unionfs translator.*/
+/*----------------------------------------------------------------------------*/
+/*Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
+  Written by Sergiu Ivanov <unlimitedscolobb@gmail.com>.
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or * (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.*/
+/*----------------------------------------------------------------------------*/
+#ifndef __NCACHE_H__
+#define __NCACHE_H__
+
+/*----------------------------------------------------------------------------*/
+#include <error.h>
+#include <hurd/netfs.h>
+/*----------------------------------------------------------------------------*/
+#include "node.h"
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Macros--------------------------------------------------------------*/
+/*The default maximal cache size*/
+#define NCACHE_SIZE 256
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*A cache chain*/
+struct ncache
+	{
+	/*the MRU end of the cache chain*/
+	node_t * mru;
+	
+	/*the LRU end of the cache chain*/
+	node_t * lru;
+	
+	/*the maximal number of nodes to cache*/
+	int size_max;
+	
+	/*the current length of the cache chain*/
+	int size_current;
+	
+	/*a lock*/
+	struct mutex lock;
+	};/*struct ncache*/
+/*----------------------------------------------------------------------------*/
+typedef struct ncache ncache_t;
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Global Variables----------------------------------------------------*/
+/*The cache size (may be overwritten by the user)*/
+extern int cache_size;
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Functions-----------------------------------------------------------*/
+/*Initializes the node cache*/
+void
+ncache_init
+	(
+	int size_max
+	);
+/*----------------------------------------------------------------------------*/
+/*Looks up the lnode and stores the result in `node`; creates a new entry
+	in the cache if the lookup fails*/
+error_t
+ncache_node_lookup
+	(
+	lnode_t * lnode,	/*search for this*/
+	node_t ** node		/*put the result here*/
+	);
+/*----------------------------------------------------------------------------*/
+/*Resets the node cache*/
+void
+ncache_reset(void);
+/*----------------------------------------------------------------------------*/
+/*Adds the given node to the cache*/
+void
+ncache_node_add
+	(
+	node_t * node	/*the node to add*/
+	);
+/*----------------------------------------------------------------------------*/
+#endif /*__NCACHE_H__*/
diff --git a/netfs-sample/node.c b/netfs-sample/node.c
new file mode 100644
index 00000000..602660b6
--- /dev/null
+++ b/netfs-sample/node.c
@@ -0,0 +1,803 @@
+/*----------------------------------------------------------------------------*/
+/*node.c*/
+/*----------------------------------------------------------------------------*/
+/*Implementation of node management strategies*/
+/*----------------------------------------------------------------------------*/
+/*Based on the code of unionfs translator.*/
+/*----------------------------------------------------------------------------*/
+/*Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
+  Written by Sergiu Ivanov <unlimitedscolobb@gmail.com>.
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or * (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+#define _GNU_SOURCE 1
+/*----------------------------------------------------------------------------*/
+#include <stdlib.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <stdio.h>
+/*----------------------------------------------------------------------------*/
+#include "debug.h"
+#include "node.h"
+#include "options.h"
+#include "lib.h"
+#include "filterfs.h"
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Global Variables----------------------------------------------------*/
+/*The lock protecting the underlying filesystem*/
+struct mutex ulfs_lock = MUTEX_INITIALIZER;
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Functions-----------------------------------------------------------*/
+/*Derives a new node from `lnode` and adds a reference to `lnode`*/
+error_t
+node_create
+(
+ lnode_t * lnode,
+ node_t ** node	/*store the result here*/
+)
+{
+  error_t err = 0;
+
+  /*Create a new netnode*/
+  netnode_t * netnode_new = malloc(sizeof(netnode_t));
+
+  /*If the memory could not be allocated*/
+  if(netnode_new == NULL)
+    err = ENOMEM;
+  else
+    {
+      /*create a new node from the netnode*/
+      node_t * node_new = netfs_make_node(netnode_new);
+
+      /*If the creation failed*/
+      if(node_new == NULL)
+	{
+	  /*set the error code*/
+	  err = ENOMEM;
+
+	  /*destroy the netnode created above*/
+	  free(netnode_new);
+
+	  /*stop*/
+	  return err;
+	}
+
+      /*link the lnode to the new node*/
+      lnode->node = node_new;
+      lnode_ref_add(lnode);
+
+      /*setup the references in the newly created node*/
+      node_new->nn->lnode = lnode;
+      node_new->nn->flags = 0;
+      node_new->nn->ncache_next = node_new->nn->ncache_prev = NULL;
+
+      /*store the result of creation in the second parameter*/
+      *node = node_new;
+    }
+
+  /*Return the result of operations*/
+  return err;
+}/*node_create*/
+/*----------------------------------------------------------------------------*/
+/*Destroys the specified node and removes a light reference from the
+  associated light node*/
+void
+node_destroy
+(
+ node_t * np
+)
+{
+  /*Die if the node does not belong to node cache*/
+  assert(!np->nn->ncache_next || !np->nn->ncache_prev);
+
+  /*Destroy the port to the underlying filesystem allocated to the node*/
+  PORT_DEALLOC(np->nn->port);
+
+  /*Lock the lnode corresponding to the current node*/
+  mutex_lock(&np->nn->lnode->lock);
+
+  /*Orphan the light node*/
+  np->nn->lnode->node = NULL;
+
+  /*Remove a reference from the lnode*/
+  lnode_ref_remove(np->nn->lnode);
+
+  /*Free the netnode and the node itself*/
+  free(np->nn);
+  free(np);
+}/*node_destroy*/
+/*----------------------------------------------------------------------------*/
+/*Creates the root node and the corresponding lnode*/
+error_t
+node_create_root
+(
+ node_t ** root_node	/*store the result here*/
+)
+{
+  /*Try to create a new lnode*/
+  lnode_t * lnode;
+  error_t err = lnode_create(NULL, &lnode);
+
+  /*Stop, if the creation failed*/
+  if(err)
+    return err;
+
+  /*Try to derive the node corresponding to `lnode`*/
+  node_t * node;
+  err = node_create(lnode, &node);
+
+  /*If the operation failed*/
+  if(err)
+    {
+      /*destroy the created lnode*/
+      lnode_destroy(lnode);
+
+      /*stop*/
+      return err;
+    }
+
+  /*Release the lock on the lnode*/
+  mutex_unlock(&lnode->lock);
+
+  /*Store the result in the parameter*/
+  *root_node = node;
+
+  /*Return the result*/
+  return err;
+}/*node_create_root*/
+/*----------------------------------------------------------------------------*/
+/*Initializes the port to the underlying filesystem for the root node*/
+error_t
+node_init_root
+(
+ node_t * node	/*the root node*/
+)
+{
+  error_t err = 0;
+
+  /*Acquire a lock for operations on the underlying filesystem*/
+  mutex_lock(&ulfs_lock);
+
+  /*Open the port to the directory specified in `dir`*/
+  node->nn->port = file_name_lookup(dir, O_READ | O_DIRECTORY, 0);
+
+  /*If the directory could not be opened*/
+  if(node->nn->port == MACH_PORT_NULL)
+    {
+      /*set the error code accordingly*/
+      err = errno;
+      LOG_MSG("node_init_root: Could not open the port for %s.", dir);
+
+      /*release the lock and stop*/
+      mutex_unlock(&ulfs_lock);
+      return err;
+    }
+
+  LOG_MSG("node_init_root: Port for %s opened successfully.", dir);
+  LOG_MSG("\tPort: 0x%lX", (unsigned long)node->nn->port);
+
+  /*Stat the root node*/
+  err = io_stat(node->nn->port, &node->nn_stat);
+  if(err)
+    {
+      /*deallocate the port*/
+      PORT_DEALLOC(node->nn->port);
+
+      LOG_MSG("node_init_root: Could not stat the root node.");
+
+      /*unlock the mutex and exit*/
+      mutex_unlock(&ulfs_lock);
+      return err;
+    }
+
+  /*Set the path to the corresponding lnode to `dir`*/
+  node->nn->lnode->path = strdup(dir);
+  if(!node->nn->lnode->path)
+    {
+      /*deallocate the port*/
+      PORT_DEALLOC(node->nn->port);
+
+      /*unlock the mutex*/
+      mutex_unlock(&ulfs_lock);
+
+      LOG_MSG("node_init_root: Could not strdup the directory.");
+      return ENOMEM;
+    }
+
+  /*The current position in dir*/
+  char * p = dir + strlen(dir);
+
+  /*Go through the path from end to beginning*/
+  for(; p >= dir; --p)
+    {
+      /*If the current character is a '/'*/
+      if(*p == '/')
+	{
+	  /*If p is not the first character*/
+	  if(p > dir)
+	    {
+	      /*if this slash is escaped, skip it*/
+	      if(*(p - 1) == '\\')
+		continue;
+	    }
+
+	  /*advance the pointer to the first character after the slash*/
+	  ++p;
+
+	  /*stop*/
+	  break;
+	}
+    }
+
+  LOG_MSG("node_init_root: The name of root node is %s.", p);
+
+  /*Set the name of the lnode to the last element in the path to dir*/
+  node->nn->lnode->name = strdup(p);
+  /*If the name of the node could not be duplicated*/
+  if(!node->nn->lnode->name)
+    {
+      /*free the name of the path to the node and deallocate teh port*/
+      free(node->nn->lnode->path);
+      PORT_DEALLOC(node->nn->port);
+
+      /*unlock the mutex*/
+      mutex_unlock(&ulfs_lock);
+
+      LOG_MSG("node_init_root: Could not strdup the name of the root node.");
+      return ENOMEM;
+    }
+
+  /*Compute the length of the name of the root node*/
+  node->nn->lnode->name_len = strlen(p);
+
+  /*Release the lock for operations on the undelying filesystem*/
+  mutex_unlock(&ulfs_lock);
+
+  /*Return the result of operations*/
+  return err;
+}/*node_init_root*/
+/*----------------------------------------------------------------------------*/
+/*Frees a list of dirents*/
+void
+node_entries_free
+(
+ node_dirent_t * dirents	/*free this*/
+)
+{
+  /*The current and the next elements*/
+  node_dirent_t * dirent, * dirent_next;
+
+  /*Go through all elements of the list*/
+  for(dirent = dirents; dirent; dirent = dirent_next)
+    {
+      /*store the next element*/
+      dirent_next = dirent->next;
+
+      /*free the dirent stored in the current element of the list*/
+      free(dirent->dirent);
+
+      /*free the current element*/
+      free(dirent);
+    }
+}/*node_entries_free*/
+/*----------------------------------------------------------------------------*/
+/*Reads the directory entries from `node`, which must be locked*/
+error_t
+node_entries_get
+(
+ node_t * node,
+ node_dirent_t ** dirents /*store the result here*/
+)
+{
+  error_t err = 0;
+
+  /*Obtain the path to the current node*/
+  char * path_to_node = node->nn->lnode->path;
+
+  /*The number of PROPERTY_PARAMs in the property*/
+  int param_entries_count = 0;
+
+  /*The length of the property*/
+  size_t property_len = (property) ? (strlen(property)) : (0);
+
+  /*The length of PROPERTY_PARAM*/
+  size_t property_param_len = strlen(PROPERTY_PARAM);
+
+  /*The full name and the filtering command*/
+  char * full_name = NULL, * cmd = NULL;
+
+  /*The lengths of the full name and the filtering command in chunks*/
+  size_t full_name_size = 1, cmd_size = 1;
+
+  /*If some property was indeed specified*/
+  if(property_len != 0)
+    {
+      /*the pointer to the current occurrence of PROPERTY_PARAM*/
+      char * occurrence = strstr(property, PROPERTY_PARAM);
+
+      /*count the number of occurrences*/
+      for(; occurrence;
+	  occurrence = strstr(occurrence + 1, PROPERTY_PARAM),
+	  ++param_entries_count);
+
+      /*try allocate the memory for the fullname and the filtering command*/
+      full_name = malloc(full_name_size * STRING_CHUNK);
+      if(!full_name)
+	return ENOMEM;
+
+      cmd = malloc(cmd_size * STRING_CHUNK);
+      if(!cmd)
+	{
+	  free(full_name);
+	  return ENOMEM;
+	}
+    }
+
+  /*Obtain the length of the path*/
+  size_t pathlen = strlen(path_to_node);
+
+  /*Checks if the given file satisfies the property. Zero value means that
+    the entry must be filtered out*/
+  int
+    check_property
+    (
+     const char * name	/*the name of the file*/
+    )
+      {
+	/*If there is no property*/
+	if(!property)
+	  /*no filtering will be applied, any name is OK*/
+	  return 0;
+
+	/*Everything OK at first*/
+	err = 0;
+
+	/*Compute the length of the full name once*/
+	size_t full_name_len = pathlen + 1 + strlen(name) + 1;
+
+	/*See how much space (in chunks) is required for the full name*/
+	int chunks = full_name_size;
+	for(; full_name_len > chunks * STRING_CHUNK; ++chunks);
+
+	/*If more memory is requied*/
+	if(chunks > full_name_size)
+	  {
+	    /*free the old full name*/
+	    free(full_name);
+
+	    /*try to allocate the new memory*/
+	    full_name = malloc(chunks * STRING_CHUNK);
+	    if(!full_name)
+	      {
+		err = ENOMEM;
+		free(cmd); /*the string for the command is definitely allocated here*/
+		return 0;
+	      }
+
+	    /*store the new size*/
+	    full_name_size = chunks;
+	  }
+
+	/*Initialize `full_name` as a valid string*/
+	full_name[0] = 0;
+
+	/*Construct the full name*/
+	strcpy(full_name, path_to_node);
+	strcat(full_name, "/");
+	strcat(full_name, name);
+
+	/*LOG_MSG("node_entries_get: Applying filter to %s...", full_name);*/
+
+	/*Compute the space required for the final filtering command*/
+	size_t sz = property_len + (strlen(full_name) - property_param_len)
+	  * param_entries_count;
+
+	/*See how much space (in chunks) is required for the command*/
+	for(chunks = cmd_size; sz > chunks * STRING_CHUNK; ++chunks);
+
+	/*If more memory is requied*/
+	if(chunks > cmd_size)
+	  {
+	    /*free the old command*/
+	    free(cmd);
+
+	    /*try to allocate the new memory*/
+	    cmd = malloc(chunks * STRING_CHUNK);
+	    if(!cmd)
+	      {
+		err = ENOMEM;
+		free(full_name);	/*the string for the full name is
+					  definitely allocated here*/
+		return 0;
+	      }
+
+	    /*store the new size*/
+	    cmd_size = chunks;
+	  }
+
+	/*Initialize `cmd` as a valid string*/
+	cmd[0] = 0;
+
+	/*The current occurence of PROPERTY_PARAM in property*/
+	char * p = strstr(property, PROPERTY_PARAM);
+
+	/*The pointer to the current position in the property*/
+	char * propp = property;
+
+	/*While the command has not been constructed*/
+	for(; p; p = strstr(propp, PROPERTY_PARAM))
+	  {
+	    /*add the new part of the property to the command*/
+	    strncat(cmd, propp, p - propp);
+
+	    /*add the filename to the command*/
+	    strcat(cmd, full_name);
+
+	    /*LOG_MSG("\tcmd = '%s'", cmd);*/
+
+	    /*advance the pointer in the property*/
+	    propp = p + property_param_len;
+
+	    /*LOG_MSG("\tpropp points at '%s'", propp);*/
+	  }
+
+	/*Copy the rest of the property to the command*/
+	strcat(cmd, propp);
+
+	/*LOG_MSG("node_entries_get: The filtering command: '%s'.", cmd);*/
+
+	/*Execute the command*/
+	int xcode = WEXITSTATUS(system(cmd));
+
+	/*Return the exit code of the command*/
+	return xcode;
+      }/*check_property*/
+
+  /*The list of dirents*/
+  struct dirent ** dirent_list, **dirent;
+
+  /*The head of the list of dirents*/
+  node_dirent_t * node_dirent_list = NULL;
+
+  /*The size of the array of pointers to dirent*/
+  size_t dirent_data_size;
+
+  /*The array of dirents*/
+  char * dirent_data;
+
+  /*Obtain the directory entries for the given node*/
+  err = dir_entries_get
+    (node->nn->port, &dirent_data, &dirent_data_size, &dirent_list);
+  if(err)
+    {
+      return err;
+    }
+
+  /*The new entry in the list*/
+  node_dirent_t * node_dirent_new;
+
+  /*The new dirent*/
+  struct dirent * dirent_new;
+
+  /*LOG_MSG("node_entries_get: Getting entries for %p", node);*/
+
+  /*The name of the current dirent*/
+  char * name;
+
+  /*The length of the current name*/
+  size_t name_len;
+
+  /*The size of the current dirent*/
+  size_t size;
+
+  /*The exit code of property*/
+  int good;
+
+  /*Go through all elements of the list of pointers to dirent*/
+  for(dirent = dirent_list; *dirent; ++dirent)
+    {
+      /*obtain the name of the current dirent*/
+      name = &((*dirent)->d_name[0]);
+
+      /*If the current dirent is either '.' or '..', skip it*/
+      if((strcmp(name, ".") == 0) ||	(strcmp(name, "..") == 0))
+	continue;
+
+      /*check if the current dirent has the property*/
+      good = check_property(name);
+      if(err)
+	break;
+
+      /*If the current entry is not good, skip it*/
+      if(good != 0)
+	continue;
+
+      /*obtain the length of the current name*/
+      name_len = strlen(name);
+
+      /*obtain the length of the current dirent*/
+      size = DIRENT_LEN(name_len);
+
+      /*create a new list element*/
+      node_dirent_new = malloc(sizeof(node_dirent_t));
+      if(!node_dirent_new)
+	{
+	  err = ENOMEM;
+	  break;
+	}
+
+      /*create a new dirent*/
+      dirent_new = malloc(size);
+      if(!dirent_new)
+	{
+	  free(node_dirent_new);
+	  err = ENOMEM;
+	  break;
+	}
+
+      /*fill the dirent with information*/
+      dirent_new->d_ino			= (*dirent)->d_ino;
+      dirent_new->d_type 		= (*dirent)->d_type;
+      dirent_new->d_reclen	= size;
+      strcpy((char *)dirent_new + DIRENT_NAME_OFFS, name);
+
+      /*add the dirent to the list*/
+      node_dirent_new->dirent = dirent_new;
+      node_dirent_new->next = node_dirent_list;
+      node_dirent_list = node_dirent_new;
+    }
+
+  /*If something went wrong in the loop*/
+  if(err)
+    /*free the list of dirents*/
+    node_entries_free(node_dirent_list);
+  else
+    /*store the list of dirents in the second parameter*/
+    *dirents = node_dirent_list;
+
+  /*Free the list of pointers to dirent*/
+  free(dirent_list);
+
+  /*Free the results of listing the dirents*/
+  munmap(dirent_data, dirent_data_size);
+
+  /*Free the full name and the command (if these are present at all)*/
+  if(full_name)
+    free(full_name);
+  if(cmd)
+    free(cmd);
+
+  /*Return the result of operations*/
+  return err;
+}/*node_entries_get*/
+/*----------------------------------------------------------------------------*/
+/*Makes sure that all ports to the underlying filesystem of `node` are up to
+  date*/
+error_t
+node_update
+(
+ node_t * node
+)
+{
+  error_t err = 0;
+
+  /*The full path to this node*/
+  char * path;
+
+  /*Stat information for `node`*/
+  io_statbuf_t stat;
+
+  /*The port to the file corresponding to `node`*/
+  file_t port;
+
+  /*If the specified node is the root node or if it must not be updated*/
+  if(NODE_IS_ROOT(node) || (node->nn->flags & FLAG_NODE_ULFS_FIXED))
+    /*do nothing*/
+    return err; /*return 0; actually*/
+
+  /*Gain exclusive access to the root node of the filesystem*/
+  mutex_lock(&netfs_root_node->lock);
+
+  /*Construct the full path to `node`*/
+  err = lnode_path_construct(node->nn->lnode, &path);
+  if(err)
+    {
+      mutex_unlock(&netfs_root_node->lock);
+      return err;
+    }
+
+  /*Deallocate `node`'s port to the underlying filesystem*/
+  if(node->nn->port)
+    PORT_DEALLOC(node->nn->port);
+
+  /*Try to lookup the file for `node` in its untranslated version*/
+  err = file_lookup
+    (
+     netfs_root_node->nn->port, path, O_READ | O_NOTRANS, O_NOTRANS,
+     0, &port, &stat
+    );
+  if(err)
+    {
+      node->nn->port = MACH_PORT_NULL;
+      err = 0; /*failure (?)*/
+      return err;
+    }
+
+  /*If the node looked up is actually the root node of filterfs filesystem*/
+  if
+    (
+     (stat.st_ino == underlying_node_stat.st_ino)
+     && (stat.st_fsid == underlying_node_stat.st_fsid)
+    )
+      /*set `err` accordingly*/
+      err = ELOOP;
+  else
+    {
+      /*deallocate the obtained port*/
+      PORT_DEALLOC(port);
+
+      /*obtain the translated version of the required node*/
+      err = file_lookup
+	(netfs_root_node->nn->port, path, O_READ, 0, 0, &port, &stat);
+    }
+
+  /*If there have been errors*/
+  if(err)
+    /*reset the port*/
+    port = MACH_PORT_NULL;
+
+  /*Store the port in the node*/
+  node->nn->port = port;
+
+  /*Remove the flag about the invalidity of the current node and set the
+    flag that the node is up-to-date*/
+  node->nn->flags &= ~FLAG_NODE_INVALIDATE;
+  node->nn->flags |= FLAG_NODE_ULFS_UPTODATE;
+
+  /*Release the lock on the root node of filterfs filesystem*/
+  mutex_unlock(&netfs_root_node->lock);
+
+  /*Return the result of operations*/
+  return err;
+}/*node_update*/
+/*----------------------------------------------------------------------------*/
+/*Computes the size of the given directory*/
+error_t
+node_get_size
+(
+ node_t * dir,
+ OFFSET_T * off
+)
+{
+  error_t err = 0;
+
+  /*The final size*/
+  size_t size = 0;
+
+  /*The number of directory entries*/
+  /*int count = 0;*/
+
+  /*The the node in the directory entries list from which we start counting*/
+  /*node_dirent_t * dirent_start = NULL;*/
+
+  /*The currently analyzed dirent*/
+  node_dirent_t * dirent_current = NULL;
+
+  /*The pointer to the beginning of the list of dirents*/
+  node_dirent_t * dirent_list = NULL;
+
+  /*The first entry we have to analyze*/
+  /*int first_entry = 2;*/
+
+  /*Takes into consideration the name of the current dirent*/
+  void
+    bump_size
+    (
+     const char * name
+    )
+      {
+	/*Increment the current size by the size of the current dirent*/
+	size += DIRENT_LEN(strlen(name));
+
+	/*Count the current dirent*/
+	/*++count;*/
+      }/*bump_size*/
+
+  /*Obtain the list of entries in the current directory*/
+  err = node_entries_get(dir, &dirent_list);
+  if(err)
+    return err;
+
+  /*Obtain the pointer to the dirent which has the number first_entry*/
+  /*Actually, the first element of the list*/
+  /*This code is included in unionfs, but it's completely useless here*/
+  /*for
+    (
+    dirent_start = dirent_list, count = 2;
+    dirent_start && count < first_entry;
+    dirent_start = dirent_start->next, ++count
+    );*/
+
+  /*Reset the count*/
+  /*count = 0;*/
+
+  /*Make space for '.' and '..' entries*/
+  /*This code is included in unionfs, but it's completely useless here*/
+  /*if(first_entry == 0)
+    bump_size(".");
+    if(first_entry <= 1)
+    bump_size("..");*/
+
+  /*See how much space is required for the node*/
+  for
+    (
+     dirent_current = dirent_list/*dirent_start*/; dirent_current;
+     dirent_current = dirent_current->next
+    )
+      bump_size(dirent_current->dirent->d_name);
+
+  /*Free the list of dirents*/
+  node_entries_free(dirent_list);
+
+  /*Return the size*/
+  *off = size;
+  return 0;
+}/*node_get_size*/
+/*----------------------------------------------------------------------------*/
+/*Remove the file called `name` under `dir`*/
+error_t
+node_unlink_file
+(
+ node_t * dir,
+ char * name
+)
+{
+  error_t err = 0;
+
+  /*The port to the file which will be unlinked*/
+  mach_port_t p;
+
+  /*Stat information about the file which will be unlinked*/
+  io_statbuf_t stat;
+
+  /*If port corresponding to `dir` is invalid*/
+  if(dir->nn->port == MACH_PORT_NULL)
+    /*stop with an error*/
+    return ENOENT; /*FIXME: Is the return value indeed meaningful here?*/
+
+  /*Attempt to lookup the specified file*/
+  err = file_lookup(dir->nn->port, name, O_NOTRANS, O_NOTRANS, 0, &p, &stat);
+  if(err)
+    return err;
+
+  /*Deallocate the obtained port*/
+  PORT_DEALLOC(p);
+
+  /*Unlink file `name` under `dir`*/
+  err = dir_unlink(dir->nn->port, name);
+  if(err)
+    return err;
+
+  return err;
+}/*node_unlink_file*/
+/*----------------------------------------------------------------------------*/
diff --git a/netfs-sample/node.c~ b/netfs-sample/node.c~
new file mode 100644
index 00000000..ec83b41b
--- /dev/null
+++ b/netfs-sample/node.c~
@@ -0,0 +1,803 @@
+/*----------------------------------------------------------------------------*/
+/*node.c*/
+/*----------------------------------------------------------------------------*/
+/*Implementation of node management strategies*/
+/*----------------------------------------------------------------------------*/
+/*Based on the code of unionfs translator.*/
+/*----------------------------------------------------------------------------*/
+/*Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
+  Written by Sergiu Ivanov <unlimitedscolobb@gmail.com>.
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or * (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+#define _GNU_SOURCE 1
+/*----------------------------------------------------------------------------*/
+#include <stdlib.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <stdio.h>
+/*----------------------------------------------------------------------------*/
+#include "debug.h"
+#include "node.h"
+#include "options.h"
+#include "lib.h"
+#include "filterfs.h"
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Global Variables----------------------------------------------------*/
+/*The lock protecting the underlying filesystem*/
+struct mutex ulfs_lock = MUTEX_INITIALIZER;
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Functions-----------------------------------------------------------*/
+/*Derives a new node from `lnode` and adds a reference to `lnode`*/
+error_t
+node_create
+	(
+	lnode_t * lnode,
+	node_t ** node	/*store the result here*/
+	)
+	{
+	error_t err = 0;
+
+	/*Create a new netnode*/
+	netnode_t * netnode_new = malloc(sizeof(netnode_t));
+	
+	/*If the memory could not be allocated*/
+	if(netnode_new == NULL)
+		err = ENOMEM;
+	else
+		{
+		/*create a new node from the netnode*/
+		node_t * node_new = netfs_make_node(netnode_new);
+		
+		/*If the creation failed*/
+		if(node_new == NULL)
+			{
+			/*set the error code*/
+			err = ENOMEM;
+
+			/*destroy the netnode created above*/
+			free(netnode_new);
+			
+			/*stop*/
+			return err;
+			}
+			
+		/*link the lnode to the new node*/
+		lnode->node = node_new;
+		lnode_ref_add(lnode);
+		
+		/*setup the references in the newly created node*/
+		node_new->nn->lnode = lnode;
+		node_new->nn->flags = 0;
+		node_new->nn->ncache_next = node_new->nn->ncache_prev = NULL;
+		
+		/*store the result of creation in the second parameter*/
+		*node = node_new;
+		}
+		
+	/*Return the result of operations*/
+	return err;
+	}/*node_create*/
+/*----------------------------------------------------------------------------*/
+/*Destroys the specified node and removes a light reference from the
+	associated light node*/
+void
+node_destroy
+	(
+	node_t * np
+	)
+	{
+	/*Die if the node does not belong to node cache*/
+	assert(!np->nn->ncache_next || !np->nn->ncache_prev);
+	
+	/*Destroy the port to the underlying filesystem allocated to the node*/
+	PORT_DEALLOC(np->nn->port);
+	
+	/*Lock the lnode corresponding to the current node*/
+	mutex_lock(&np->nn->lnode->lock);
+	
+	/*Orphan the light node*/
+	np->nn->lnode->node = NULL;
+	
+	/*Remove a reference from the lnode*/
+	lnode_ref_remove(np->nn->lnode);
+	
+	/*Free the netnode and the node itself*/
+	free(np->nn);
+	free(np);
+	}/*node_destroy*/
+/*----------------------------------------------------------------------------*/
+/*Creates the root node and the corresponding lnode*/
+error_t
+node_create_root
+	(
+	node_t ** root_node	/*store the result here*/
+	)
+	{
+	/*Try to create a new lnode*/
+	lnode_t * lnode;
+	error_t err = lnode_create(NULL, &lnode);
+	
+	/*Stop, if the creation failed*/
+	if(err)
+		return err;
+		
+	/*Try to derive the node corresponding to `lnode`*/
+	node_t * node;
+	err = node_create(lnode, &node);
+	
+	/*If the operation failed*/
+	if(err)
+		{
+		/*destroy the created lnode*/
+		lnode_destroy(lnode);
+		
+		/*stop*/
+		return err;
+		}
+		
+	/*Release the lock on the lnode*/
+	mutex_unlock(&lnode->lock);
+	
+	/*Store the result in the parameter*/
+	*root_node = node;
+	
+	/*Return the result*/
+	return err;
+	}/*node_create_root*/
+/*----------------------------------------------------------------------------*/
+/*Initializes the port to the underlying filesystem for the root node*/
+error_t
+node_init_root
+	(
+	node_t * node	/*the root node*/
+	)
+	{
+	error_t err = 0;
+
+	/*Acquire a lock for operations on the underlying filesystem*/
+	mutex_lock(&ulfs_lock);
+	
+	/*Open the port to the directory specified in `dir`*/
+	node->nn->port = file_name_lookup(dir, O_READ | O_DIRECTORY, 0);
+	
+	/*If the directory could not be opened*/
+	if(node->nn->port == MACH_PORT_NULL)
+		{
+		/*set the error code accordingly*/
+		err = errno;
+		LOG_MSG("node_init_root: Could not open the port for %s.", dir);
+		
+		/*release the lock and stop*/
+		mutex_unlock(&ulfs_lock);
+		return err;
+		}
+
+	LOG_MSG("node_init_root: Port for %s opened successfully.", dir);
+	LOG_MSG("\tPort: 0x%lX", (unsigned long)node->nn->port);
+	
+	/*Stat the root node*/
+	err = io_stat(node->nn->port, &node->nn_stat);
+	if(err)
+		{
+		/*deallocate the port*/
+		PORT_DEALLOC(node->nn->port);
+		
+		LOG_MSG("node_init_root: Could not stat the root node.");
+		
+		/*unlock the mutex and exit*/
+		mutex_unlock(&ulfs_lock);
+		return err;
+		}
+	
+	/*Set the path to the corresponding lnode to `dir`*/
+	node->nn->lnode->path = strdup(dir);
+	if(!node->nn->lnode->path)
+		{
+		/*deallocate the port*/
+		PORT_DEALLOC(node->nn->port);
+
+		/*unlock the mutex*/
+		mutex_unlock(&ulfs_lock);
+
+		LOG_MSG("node_init_root: Could not strdup the directory.");
+		return ENOMEM;
+		}
+	
+	/*The current position in dir*/
+	char * p = dir + strlen(dir);
+	
+	/*Go through the path from end to beginning*/
+	for(; p >= dir; --p)
+		{
+		/*If the current character is a '/'*/
+		if(*p == '/')
+			{
+			/*If p is not the first character*/
+			if(p > dir)
+				{
+				/*if this slash is escaped, skip it*/
+				if(*(p - 1) == '\\')
+					continue;
+				}
+			
+			/*advance the pointer to the first character after the slash*/
+			++p;
+
+			/*stop*/
+			break;
+			}
+		}
+		
+	LOG_MSG("node_init_root: The name of root node is %s.", p);
+	
+	/*Set the name of the lnode to the last element in the path to dir*/
+	node->nn->lnode->name = strdup(p);
+	/*If the name of the node could not be duplicated*/
+	if(!node->nn->lnode->name)
+		{
+		/*free the name of the path to the node and deallocate teh port*/
+		free(node->nn->lnode->path);
+		PORT_DEALLOC(node->nn->port);
+		
+		/*unlock the mutex*/
+		mutex_unlock(&ulfs_lock);
+
+		LOG_MSG("node_init_root: Could not strdup the name of the root node.");
+		return ENOMEM;
+		}
+	
+	/*Compute the length of the name of the root node*/
+	node->nn->lnode->name_len = strlen(p);
+
+	/*Release the lock for operations on the undelying filesystem*/
+	mutex_unlock(&ulfs_lock);
+	
+	/*Return the result of operations*/
+	return err;
+	}/*node_init_root*/
+/*----------------------------------------------------------------------------*/
+/*Frees a list of dirents*/
+void
+node_entries_free
+	(
+	node_dirent_t * dirents	/*free this*/
+	)
+	{
+	/*The current and the next elements*/
+	node_dirent_t * dirent, * dirent_next;
+	
+	/*Go through all elements of the list*/
+	for(dirent = dirents; dirent; dirent = dirent_next)
+		{
+		/*store the next element*/
+		dirent_next = dirent->next;
+		
+		/*free the dirent stored in the current element of the list*/
+		free(dirent->dirent);
+		
+		/*free the current element*/
+		free(dirent);
+		}
+	}/*node_entries_free*/
+/*----------------------------------------------------------------------------*/
+/*Reads the directory entries from `node`, which must be locked*/
+error_t
+node_entries_get
+	(
+	node_t * node,
+	node_dirent_t ** dirents /*store the result here*/
+	)
+	{
+	error_t err = 0;
+
+	/*Obtain the path to the current node*/
+	char * path_to_node = node->nn->lnode->path;
+	
+	/*The number of PROPERTY_PARAMs in the property*/
+	int param_entries_count = 0;
+	
+	/*The length of the property*/
+	size_t property_len = (property) ? (strlen(property)) : (0);
+	
+	/*The length of PROPERTY_PARAM*/
+	size_t property_param_len = strlen(PROPERTY_PARAM);
+
+	/*The full name and the filtering command*/
+	char * full_name = NULL, * cmd = NULL;
+
+	/*The lengths of the full name and the filtering command in chunks*/
+	size_t full_name_size = 1, cmd_size = 1;
+
+	/*If some property was indeed specified*/
+	if(property_len != 0)
+		{
+		/*the pointer to the current occurrence of PROPERTY_PARAM*/
+		char * occurrence = strstr(property, PROPERTY_PARAM);
+		
+		/*count the number of occurrences*/
+		for(; occurrence;
+			occurrence = strstr(occurrence + 1, PROPERTY_PARAM),
+			++param_entries_count);
+
+		/*try allocate the memory for the fullname and the filtering command*/
+		full_name = malloc(full_name_size * STRING_CHUNK);
+		if(!full_name)
+			return ENOMEM;
+
+		cmd = malloc(cmd_size * STRING_CHUNK);
+		if(!cmd)
+			{
+			free(full_name);
+			return ENOMEM;
+			}
+		}
+
+	/*Obtain the length of the path*/
+	size_t pathlen = strlen(path_to_node);
+
+	/*Checks if the given file satisfies the property. Zero value means that
+		the entry must be filtered out*/
+	int
+	check_property
+		(
+		const char * name	/*the name of the file*/
+		)
+		{
+		/*If there is no property*/
+		if(!property)
+			/*no filtering will be applied, any name is OK*/
+			return 0;
+		
+		/*Everything OK at first*/
+		err = 0;
+		
+		/*Compute the length of the full name once*/
+		size_t full_name_len = pathlen + 1 + strlen(name) + 1;
+
+		/*See how much space (in chunks) is required for the full name*/
+		int chunks = full_name_size;
+		for(; full_name_len > chunks * STRING_CHUNK; ++chunks);
+		
+		/*If more memory is requied*/
+		if(chunks > full_name_size)
+			{
+			/*free the old full name*/
+			free(full_name);
+
+			/*try to allocate the new memory*/
+			full_name = malloc(chunks * STRING_CHUNK);
+			if(!full_name)
+				{
+				err = ENOMEM;
+				free(cmd); /*the string for the command is definitely allocated here*/
+				return 0;
+				}
+			
+			/*store the new size*/
+			full_name_size = chunks;
+			}
+		
+		/*Initialize `full_name` as a valid string*/
+		full_name[0] = 0;
+		
+		/*Construct the full name*/
+		strcpy(full_name, path_to_node);
+		strcat(full_name, "/");
+		strcat(full_name, name);
+		
+		/*LOG_MSG("node_entries_get: Applying filter to %s...", full_name);*/
+		
+		/*Compute the space required for the final filtering command*/
+		size_t sz = property_len + (strlen(full_name) - property_param_len)
+			* param_entries_count;
+		
+		/*See how much space (in chunks) is required for the command*/
+		for(chunks = cmd_size; sz > chunks * STRING_CHUNK; ++chunks);
+		
+		/*If more memory is requied*/
+		if(chunks > cmd_size)
+			{
+			/*free the old command*/
+			free(cmd);
+
+			/*try to allocate the new memory*/
+			cmd = malloc(chunks * STRING_CHUNK);
+			if(!cmd)
+				{
+				err = ENOMEM;
+				free(full_name);	/*the string for the full name is
+														definitely allocated here*/
+				return 0;
+				}
+			
+			/*store the new size*/
+			cmd_size = chunks;
+			}
+
+		/*Initialize `cmd` as a valid string*/
+		cmd[0] = 0;
+			
+		/*The current occurence of PROPERTY_PARAM in property*/
+		char * p = strstr(property, PROPERTY_PARAM);
+		
+		/*The pointer to the current position in the property*/
+		char * propp = property;
+		
+		/*While the command has not been constructed*/
+		for(; p; p = strstr(propp, PROPERTY_PARAM))
+			{
+			/*add the new part of the property to the command*/
+			strncat(cmd, propp, p - propp);
+			
+			/*add the filename to the command*/
+			strcat(cmd, full_name);
+			
+			/*LOG_MSG("\tcmd = '%s'", cmd);*/
+
+			/*advance the pointer in the property*/
+			propp = p + property_param_len;
+
+			/*LOG_MSG("\tpropp points at '%s'", propp);*/
+			}
+		
+		/*Copy the rest of the property to the command*/
+		strcat(cmd, propp);
+		
+		/*LOG_MSG("node_entries_get: The filtering command: '%s'.", cmd);*/
+
+		/*Execute the command*/
+		int xcode = WEXITSTATUS(system(cmd));
+		
+		/*Return the exit code of the command*/
+		return xcode;
+		}/*check_property*/
+
+	/*The list of dirents*/
+	struct dirent ** dirent_list, **dirent;
+	
+	/*The head of the list of dirents*/
+	node_dirent_t * node_dirent_list = NULL;
+	
+	/*The size of the array of pointers to dirent*/
+	size_t dirent_data_size;
+	
+	/*The array of dirents*/
+	char * dirent_data;
+
+	/*Obtain the directory entries for the given node*/
+	err = dir_entries_get
+		(node->nn->port, &dirent_data, &dirent_data_size, &dirent_list);
+	if(err)
+		{
+		return err;
+		}
+		
+	/*The new entry in the list*/
+	node_dirent_t * node_dirent_new;
+	
+	/*The new dirent*/
+	struct dirent * dirent_new;
+	
+	/*LOG_MSG("node_entries_get: Getting entries for %p", node);*/
+
+	/*The name of the current dirent*/
+	char * name;
+
+	/*The length of the current name*/
+	size_t name_len;
+	
+	/*The size of the current dirent*/
+	size_t size;
+	
+	/*The exit code of property*/
+	int good;
+	
+	/*Go through all elements of the list of pointers to dirent*/
+	for(dirent = dirent_list; *dirent; ++dirent)
+		{
+		/*obtain the name of the current dirent*/
+		name = &((*dirent)->d_name[0]);
+		
+		/*If the current dirent is either '.' or '..', skip it*/
+		if((strcmp(name, ".") == 0) ||	(strcmp(name, "..") == 0))
+			continue;
+		
+		/*check if the current dirent has the property*/
+		good = check_property(name);
+		if(err)
+			break;
+ 		
+		/*If the current entry is not good, skip it*/
+		if(good != 0)
+			continue;
+		
+		/*obtain the length of the current name*/
+		name_len = strlen(name);
+		
+		/*obtain the length of the current dirent*/
+		size = DIRENT_LEN(name_len);
+		
+		/*create a new list element*/
+		node_dirent_new = malloc(sizeof(node_dirent_t));
+		if(!node_dirent_new)
+			{
+			err = ENOMEM;
+			break;
+			}
+			
+		/*create a new dirent*/
+		dirent_new = malloc(size);
+		if(!dirent_new)
+			{
+			free(node_dirent_new);
+			err = ENOMEM;
+			break;
+			}
+			
+		/*fill the dirent with information*/
+		dirent_new->d_ino			= (*dirent)->d_ino;
+		dirent_new->d_type 		= (*dirent)->d_type;
+		dirent_new->d_reclen	= size;
+		strcpy((char *)dirent_new + DIRENT_NAME_OFFS, name);
+		
+		/*add the dirent to the list*/
+		node_dirent_new->dirent = dirent_new;
+		node_dirent_new->next = node_dirent_list;
+		node_dirent_list = node_dirent_new;
+		}
+	
+	/*If something went wrong in the loop*/
+	if(err)
+		/*free the list of dirents*/
+		node_entries_free(node_dirent_list);
+	else
+		/*store the list of dirents in the second parameter*/
+		*dirents = node_dirent_list;
+	
+	/*Free the list of pointers to dirent*/
+	free(dirent_list);
+	
+	/*Free the results of listing the dirents*/
+	munmap(dirent_data, dirent_data_size);
+
+	/*Free the full name and the command (if these are present at all)*/
+	if(full_name)
+		free(full_name);
+	if(cmd)
+		free(cmd);
+	
+	/*Return the result of operations*/
+	return err;
+	}/*node_entries_get*/
+/*----------------------------------------------------------------------------*/
+/*Makes sure that all ports to the underlying filesystem of `node` are up to
+	date*/
+error_t
+node_update
+	(
+	node_t * node
+	)
+	{
+	error_t err = 0;
+
+	/*The full path to this node*/
+	char * path;
+	
+	/*Stat information for `node`*/
+	io_statbuf_t stat;
+	
+	/*The port to the file corresponding to `node`*/
+	file_t port;
+
+	/*If the specified node is the root node or if it must not be updated*/
+	if(NODE_IS_ROOT(node) || (node->nn->flags & FLAG_NODE_ULFS_FIXED))
+		/*do nothing*/
+		return err; /*return 0; actually*/
+		
+	/*Gain exclusive access to the root node of the filesystem*/
+	mutex_lock(&netfs_root_node->lock);
+	
+	/*Construct the full path to `node`*/
+	err = lnode_path_construct(node->nn->lnode, &path);
+	if(err)
+		{
+		mutex_unlock(&netfs_root_node->lock);
+		return err;
+		}
+		
+	/*Deallocate `node`'s port to the underlying filesystem*/
+	if(node->nn->port)
+		PORT_DEALLOC(node->nn->port);
+		
+	/*Try to lookup the file for `node` in its untranslated version*/
+	err = file_lookup
+		(
+		netfs_root_node->nn->port, path, O_READ | O_NOTRANS, O_NOTRANS,
+		0, &port, &stat
+		);
+	if(err)
+		{
+		node->nn->port = MACH_PORT_NULL;
+		err = 0; /*failure (?)*/
+		return err;
+		}
+	
+	/*If the node looked up is actually the root node of filterfs filesystem*/
+	if
+		(
+		(stat.st_ino == underlying_node_stat.st_ino)
+		&& (stat.st_fsid == underlying_node_stat.st_fsid)
+		)
+		/*set `err` accordingly*/
+		err = ELOOP;
+	else
+		{
+		/*deallocate the obtained port*/
+		PORT_DEALLOC(port);
+		
+		/*obtain the translated version of the required node*/
+		err = file_lookup
+			(netfs_root_node->nn->port, path, O_READ, 0, 0, &port, &stat);
+		}
+		
+	/*If there have been errors*/
+	if(err)
+		/*reset the port*/
+		port = MACH_PORT_NULL;
+		
+	/*Store the port in the node*/
+	node->nn->port = port;
+	
+	/*Remove the flag about the invalidity of the current node and set the
+		flag that the node is up-to-date*/
+	node->nn->flags &= ~FLAG_NODE_INVALIDATE;
+	node->nn->flags |= FLAG_NODE_ULFS_UPTODATE;
+	
+	/*Release the lock on the root node of filterfs filesystem*/
+	mutex_unlock(&netfs_root_node->lock);
+	
+	/*Return the result of operations*/
+	return err;
+	}/*node_update*/
+/*----------------------------------------------------------------------------*/
+/*Computes the size of the given directory*/
+error_t
+node_get_size
+	(
+	node_t * dir,
+	OFFSET_T * off
+	)
+	{
+	error_t err = 0;
+
+	/*The final size*/
+	size_t size = 0;
+	
+	/*The number of directory entries*/
+	/*int count = 0;*/
+	
+	/*The the node in the directory entries list from which we start counting*/
+	/*node_dirent_t * dirent_start = NULL;*/
+	
+	/*The currently analyzed dirent*/
+	node_dirent_t * dirent_current = NULL;
+	
+	/*The pointer to the beginning of the list of dirents*/
+	node_dirent_t * dirent_list = NULL;
+	
+	/*The first entry we have to analyze*/
+	/*int first_entry = 2;*/
+	
+	/*Takes into consideration the name of the current dirent*/
+	void
+	bump_size
+		(
+		const char * name
+		)
+		{
+		/*Increment the current size by the size of the current dirent*/
+		size += DIRENT_LEN(strlen(name));
+		
+		/*Count the current dirent*/
+		/*++count;*/
+		}/*bump_size*/
+		
+	/*Obtain the list of entries in the current directory*/
+	err = node_entries_get(dir, &dirent_list);
+	if(err)
+		return err;
+	
+	/*Obtain the pointer to the dirent which has the number first_entry*/
+	/*Actually, the first element of the list*/
+	/*This code is included in unionfs, but it's completely useless here*/
+	/*for
+		(
+		dirent_start = dirent_list, count = 2;
+		dirent_start && count < first_entry;
+		dirent_start = dirent_start->next, ++count
+		);*/
+	
+	/*Reset the count*/
+	/*count = 0;*/
+	
+	/*Make space for '.' and '..' entries*/
+	/*This code is included in unionfs, but it's completely useless here*/
+	/*if(first_entry == 0)
+		bump_size(".");
+	if(first_entry <= 1)
+		bump_size("..");*/
+	
+	/*See how much space is required for the node*/
+	for
+		(
+		dirent_current = dirent_list/*dirent_start*/; dirent_current;
+		dirent_current = dirent_current->next
+		)
+		bump_size(dirent_current->dirent->d_name);
+		
+	/*Free the list of dirents*/
+	node_entries_free(dirent_list);
+	
+	/*Return the size*/
+	*off = size;
+	return 0;
+	}/*node_get_size*/
+/*----------------------------------------------------------------------------*/
+/*Remove the file called `name` under `dir`*/
+error_t
+node_unlink_file
+	(
+	node_t * dir,
+	char * name
+	)
+	{
+	error_t err = 0;
+
+	/*The port to the file which will be unlinked*/
+	mach_port_t p;
+	
+	/*Stat information about the file which will be unlinked*/
+	io_statbuf_t stat;
+	
+	/*If port corresponding to `dir` is invalid*/
+	if(dir->nn->port == MACH_PORT_NULL)
+		/*stop with an error*/
+		return ENOENT; /*FIXME: Is the return value indeed meaningful here?*/
+	
+	/*Attempt to lookup the specified file*/
+	err = file_lookup(dir->nn->port, name, O_NOTRANS, O_NOTRANS, 0, &p, &stat);
+	if(err)
+		return err;
+	
+	/*Deallocate the obtained port*/
+	PORT_DEALLOC(p);
+	
+	/*Unlink file `name` under `dir`*/
+	err = dir_unlink(dir->nn->port, name);
+	if(err)
+		return err;
+	
+	return err;
+	}/*node_unlink_file*/
+/*----------------------------------------------------------------------------*/
diff --git a/netfs-sample/node.h b/netfs-sample/node.h
new file mode 100644
index 00000000..dcd618d4
--- /dev/null
+++ b/netfs-sample/node.h
@@ -0,0 +1,168 @@
+/*----------------------------------------------------------------------------*/
+/*node.h*/
+/*----------------------------------------------------------------------------*/
+/*Node management. Also see lnode.h*/
+/*----------------------------------------------------------------------------*/
+/*Based on the code of unionfs translator.*/
+/*----------------------------------------------------------------------------*/
+/*Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
+  Written by Sergiu Ivanov <unlimitedscolobb@gmail.com>.
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or * (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.*/
+/*----------------------------------------------------------------------------*/
+#ifndef __NODE_H__
+#define __NODE_H__
+
+/*----------------------------------------------------------------------------*/
+#include <error.h>
+#include <sys/stat.h>
+#include <hurd/netfs.h>
+/*----------------------------------------------------------------------------*/
+#include "lnode.h"
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Macros--------------------------------------------------------------*/
+/*Checks whether the give node is the root of the filterfs filesystem*/
+#define NODE_IS_ROOT(n) (((n)->nn->lnode->dir) ? (0) : (1))
+/*----------------------------------------------------------------------------*/
+/*Node flags*/
+#define FLAG_NODE_ULFS_FIXED 		0x00000001	/*this node should not be updated*/
+#define FLAG_NODE_INVALIDATE		0x00000002 	/*this node must be updated*/
+#define FLAG_NODE_ULFS_UPTODATE	0x00000004 	/*this node has just been updated*/
+/*----------------------------------------------------------------------------*/
+/*The type of offset corresponding to the current platform*/
+#ifdef __USE_FILE_OFFSET64
+#	define OFFSET_T __off64_t
+#else
+#	define OFFSET_T __off_t
+#endif /*__USE_FILE_OFFSET64*/
+/*----------------------------------------------------------------------------*/
+/*The size of a chunk of a string (for a small optimization in checking
+	the property)*/
+#define STRING_CHUNK 256
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*The user-defined node for libnetfs*/
+struct netnode
+	{
+	/*the reference to the corresponding light node*/
+	lnode_t * lnode;
+	
+	/*the flags associated with this node (might be not required)*/
+	int flags;
+
+	/*a port to the underlying filesystem*/
+	file_t port;
+	
+	/*the neighbouring entries in the cache*/
+	node_t * ncache_prev, * ncache_next;
+	};/*struct netnode*/
+/*----------------------------------------------------------------------------*/
+typedef struct netnode netnode_t;
+/*----------------------------------------------------------------------------*/
+/*A list element containing directory entry*/
+struct node_dirent
+	{
+	/*the directory entry*/
+	struct dirent * dirent;
+	
+	/*the next element*/
+	struct node_dirent * next;
+	};/*struct node_dirent*/
+/*----------------------------------------------------------------------------*/
+typedef struct node_dirent node_dirent_t;
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Global Variables----------------------------------------------------*/
+/*The lock protecting the underlying filesystem*/
+extern struct mutex ulfs_lock;
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Functions-----------------------------------------------------------*/
+/*Derives a new node from `lnode` and adds a reference to `lnode`*/
+error_t
+node_create
+	(
+	lnode_t * lnode,
+	node_t ** node	/*store the result here*/
+	);
+/*----------------------------------------------------------------------------*/
+/*Destroys the specified node and removes a light reference from the
+	associated light node*/
+void
+node_destroy
+	(
+	node_t * np
+	);
+/*----------------------------------------------------------------------------*/
+/*Creates the root node and the corresponding lnode*/
+error_t
+node_create_root
+	(
+	node_t ** root_node	/*store the result here*/
+	);
+/*----------------------------------------------------------------------------*/
+/*Initializes the port to the underlying filesystem for the root node*/
+error_t
+node_init_root
+	(
+	node_t * node	/*the root node*/
+	);
+/*----------------------------------------------------------------------------*/
+/*Frees a list of dirents*/
+void
+node_entries_free
+	(
+	node_dirent_t * dirents	/*free this*/
+	);
+/*----------------------------------------------------------------------------*/
+/*Reads the directory entries from `node`, which must be locked*/
+error_t
+node_entries_get
+	(
+	node_t * node,
+	node_dirent_t ** dirents /*store the result here*/
+	);
+/*----------------------------------------------------------------------------*/
+/*Makes sure that all ports to the underlying filesystem of `node` are up to
+	date*/
+error_t
+node_update
+	(
+	node_t * node
+	);
+/*----------------------------------------------------------------------------*/
+/*Computes the size of the given directory*/
+error_t
+node_get_size
+	(
+	node_t * dir,
+	OFFSET_T * off
+	);
+/*----------------------------------------------------------------------------*/
+/*Remove the file called `name` under `dir`*/
+error_t
+node_unlink_file
+	(
+	node_t * dir,
+	char * name
+	);
+/*----------------------------------------------------------------------------*/
+#endif /*__NODE_H__*/
diff --git a/netfs-sample/options.c b/netfs-sample/options.c
new file mode 100644
index 00000000..c39d3f2b
--- /dev/null
+++ b/netfs-sample/options.c
@@ -0,0 +1,255 @@
+/*----------------------------------------------------------------------------*/
+/*options.h*/
+/*----------------------------------------------------------------------------*/
+/*Definitions for parsing the command line switches*/
+/*----------------------------------------------------------------------------*/
+/*Based on the code of unionfs translator.*/
+/*----------------------------------------------------------------------------*/
+/*Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
+  Written by Sergiu Ivanov <unlimitedscolobb@gmail.com>.
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or * (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+#define _GNU_SOURCE 1
+/*----------------------------------------------------------------------------*/
+#include <argp.h>
+#include <error.h>
+/*----------------------------------------------------------------------------*/
+#include "debug.h"
+#include "options.h"
+#include "ncache.h"
+#include "node.h"
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Macros--------------------------------------------------------------*/
+/*Short documentation for argp*/
+#define ARGS_DOC	"DIR"
+#define DOC 			"Shows the contents of DIR filtered according to PROPERTY.\
+ If DIR is not specified, ~/ is assumed."
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Forward Declarations------------------------------------------------*/
+/*Argp parser function for the common options*/
+static
+error_t
+argp_parse_common_options
+	(
+	int key,
+	char * arg,
+	struct argp_state * state
+	);
+/*----------------------------------------------------------------------------*/
+/*Argp parser function for the startup options*/
+static
+error_t
+argp_parse_startup_options
+	(
+	int key,
+	char * arg,
+	struct argp_state * state
+	);
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Global Variables----------------------------------------------------*/
+/*This variable is set to a non-zero value after the parsing of starup options
+	is finished*/
+/*Whenever the argument parser is later called to modify the
+	options of filterfs the root node will be initialized accordingly directly
+	by the parser*/
+static int parsing_startup_options_finished;
+/*----------------------------------------------------------------------------*/
+/*Argp options common to both the runtime and the startup parser*/
+static const struct argp_option argp_common_options[] =
+	{
+	{OPT_LONG_CACHE_SIZE, OPT_CACHE_SIZE, "SIZE", 0,
+		"The maximal number of nodes in the node cache"},
+	{OPT_LONG_PROPERTY, OPT_PROPERTY, "PROPERTY", 0,
+		"The command which will act as a filter"}
+	};
+/*----------------------------------------------------------------------------*/
+/*Argp options only meaningful for startupp parsing*/
+static const struct argp_option argp_startup_options[] =
+	{
+	{0}
+	};
+/*----------------------------------------------------------------------------*/
+/*Argp parser for only the common options*/
+static const struct argp argp_parser_common_options =
+	{argp_common_options, argp_parse_common_options, 0, 0, 0};
+/*----------------------------------------------------------------------------*/
+/*Argp parser for only the startup options*/
+static const struct argp argp_parser_startup_options =
+	{argp_startup_options, argp_parse_startup_options, 0, 0, 0};
+/*----------------------------------------------------------------------------*/
+/*The list of children parsers for runtime arguments*/
+static const struct argp_child argp_children_runtime[] =
+	{
+	{&argp_parser_common_options},
+	{&netfs_std_runtime_argp},
+	{0}
+	};
+/*----------------------------------------------------------------------------*/
+/*The list of children parsers for startup arguments*/
+static const struct argp_child argp_children_startup[] =
+	{
+	{&argp_parser_startup_options},
+	{&argp_parser_common_options},
+	{&netfs_std_startup_argp},
+	{0}
+	};
+/*----------------------------------------------------------------------------*/
+/*The version of the server for argp*/
+const char * argp_program_version = "0.0";
+/*----------------------------------------------------------------------------*/
+/*The arpg parser for runtime arguments*/
+struct argp argp_runtime =
+	{0, 0, 0, 0, argp_children_runtime};
+/*----------------------------------------------------------------------------*/
+/*The argp parser for startup arguments*/
+struct argp argp_startup =
+	{0, 0, ARGS_DOC, DOC, argp_children_startup};
+/*----------------------------------------------------------------------------*/
+/*The filtering command*/
+char * property = NULL;
+/*----------------------------------------------------------------------------*/
+/*The directory to filter*/
+char * dir = NULL;
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Functions-----------------------------------------------------------*/
+/*Argp parser function for the common options*/
+static
+error_t
+argp_parse_common_options
+	(
+	int key,
+	char * arg,
+	struct argp_state * state
+	)
+	{
+	error_t err = 0;
+	
+	/*Go through the possible options*/
+	switch(key)
+		{
+		case OPT_CACHE_SIZE:
+			{
+			/*store the new cache-size*/
+			ncache_size = strtol(arg, NULL, 10);
+			
+			break;
+			}
+		case OPT_PROPERTY:
+			{
+			/*try to duplicate the filtering command*/
+			property = strdup(arg);
+			if(!property)
+				error(EXIT_FAILURE, ENOMEM, "Could not strdup the property");
+				
+			break;
+			}
+		case ARGP_KEY_ARG: /*the directory to filter*/
+			{
+			/*try to duplicate the directory name*/
+			dir = strdup(arg);
+			if(!dir)
+				error(EXIT_FAILURE, ENOMEM, "argp_parse_common_options: "
+					"Could not strdup the directory");
+				
+			/*fill all trailing spaces with 0*/
+			int i = strlen(dir) - 1;
+			/*for(i = strlen(dir) - 1; (i >= 0) && (dir[i] == ' '); dir[i--] = 0);*/
+				/*the original filename may contain spaces*/
+			
+			/*If the last non blank symbol is a '/' and it's not the only one*/
+			if((dir[i] == '/') && (i != 0))
+				/*put 0 instead*/
+				dir[i] = 0;
+				
+			LOG_MSG("argp_parse_common_options: Filtering the directory %s.", dir);
+
+			break;
+			}
+		case ARGP_KEY_END:
+			{
+			/*If parsing of startup options has not finished*/
+			if(!parsing_startup_options_finished)
+				{
+				/*reset the cache*/
+				ncache_reset();
+				
+				/*If the directory has not been specified*/
+				if(!dir)
+					{
+					/*assume the directory to be the home directory*/
+					;
+
+					/*FIXME: The default directory is /var/tmp*/
+					dir = "/var/tmp";
+					}
+				
+				/*set the flag that the startup options have already been parsed*/
+				parsing_startup_options_finished = 1;
+				}
+			else
+				{
+/*TODO: Take care of runtime calls modifying the property*/
+				}
+			}
+		/*If the option could not be recognized*/
+		default:
+			{
+			/*set the error code*/
+			err = ARGP_ERR_UNKNOWN;
+			}
+		}
+		
+	/*Return the result*/
+	return err;
+	}/*argp_parse_common_options*/
+/*----------------------------------------------------------------------------*/
+/*Argp parser function for the startup options*/
+static
+error_t
+argp_parse_startup_options
+	(
+	int key,
+	char * arg,
+	struct argp_state * state
+	)
+	{
+	/*Do nothing in a beautiful way*/
+	error_t err = 0;
+	
+	switch(key)
+		{
+		default:
+			{
+			err = ARGP_ERR_UNKNOWN;
+			
+			break;
+			}
+		}
+	
+	return err;
+	}/*argp_parse_startup_options*/
+/*----------------------------------------------------------------------------*/
diff --git a/netfs-sample/options.h b/netfs-sample/options.h
new file mode 100644
index 00000000..0f917bb0
--- /dev/null
+++ b/netfs-sample/options.h
@@ -0,0 +1,64 @@
+/*----------------------------------------------------------------------------*/
+/*options.h*/
+/*----------------------------------------------------------------------------*/
+/*Declarations for parsing the command line switches*/
+/*----------------------------------------------------------------------------*/
+/*Based on the code of unionfs translator.*/
+/*----------------------------------------------------------------------------*/
+/*Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
+  Written by Sergiu Ivanov <unlimitedscolobb@gmail.com>.
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or * (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.*/
+/*----------------------------------------------------------------------------*/
+#ifndef __OPTIONS_H__
+#define __OPTIONS_H__
+
+/*----------------------------------------------------------------------------*/
+/*--------Macros--------------------------------------------------------------*/
+/*The possible short options*/
+#define OPT_CACHE_SIZE 'c'
+/*the property according to which filtering will be performed*/
+#define OPT_PROPERTY	 'p'
+/*----------------------------------------------------------------------------*/
+/*The corresponding long options*/
+#define OPT_LONG_CACHE_SIZE "cache-size"
+#define OPT_LONG_PROPERTY 	"property"
+/*----------------------------------------------------------------------------*/
+/*Makes a long option out of option name*/
+#define OPT_LONG(o) "--"o
+/*----------------------------------------------------------------------------*/
+/*The substring of the property which shall be replaced by the filename*/
+#define PROPERTY_PARAM "{}"
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*--------Global Variables----------------------------------------------------*/
+/*The argp parser for startup arguments*/
+extern struct argp argp_startup;
+/*----------------------------------------------------------------------------*/
+/*The argp parser for rutime arguments*/
+extern struct argp argp_runtime;
+/*----------------------------------------------------------------------------*/
+/*The number of nodes in cache (see ncache.{c,h})*/
+extern int ncache_size;
+/*----------------------------------------------------------------------------*/
+/*The filtering command*/
+extern char * property;
+/*----------------------------------------------------------------------------*/
+/*The directory to filter*/
+extern char * dir;
+/*----------------------------------------------------------------------------*/
+#endif /*__OPTIONS_H__*/