This is my initial working version.

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

47 files changed, 44321 insertions, 0 deletions

diff --git a/unionfs/AUTHORS b/unionfs/AUTHORS
new file mode 100644
index 00000000..1cc95387
--- /dev/null
+++ b/unionfs/AUTHORS
@@ -0,0 +1,2 @@
+* Moritz Schulte <moritz@duesseldorf.ccc.de>
+* Gianluca Guida <glguida@gmail.com>
diff --git a/unionfs/BUGS b/unionfs/BUGS
new file mode 100644
index 00000000..56209654
--- /dev/null
+++ b/unionfs/BUGS
@@ -0,0 +1,5 @@
+Known bugs:
+
+ * unionfs hangs when looking up recursive links, which point into the
+   unionfs
+ * emacs hangs when trying to save files in unionfs
diff --git a/unionfs/CAVEAT b/unionfs/CAVEAT
new file mode 100644
index 00000000..dbb88136
--- /dev/null
+++ b/unionfs/CAVEAT
@@ -0,0 +1,25 @@
+While using unionfs, you could experience more permission errors or 
+difficult or impossible file or directory deletion. This is a list of
+things that can happen.
+
+WARNINGS:
+
+- If the translator is run as by an unpriviledged user, other users will fail
+to create files or directory, since the translator won't be able to change
+the ownership of the file.
+
+
+PROBLEMS:
+
+- If there's a name conflict in underlying filesystems between directories 
+and files -- say that "foo" is a directory in underlying filesystem "a" while
+is a file in the underlying filesystem "b" -- then unionfs will be unable to
+delete this entry. This is a structural BUG (there's no clean way to solve it),
+and should be fixed.
+
+- If there's a name conflict in underlying filesystems between directories
+(or between files), and the user has not permission to delete _ALL_ the 
+entries -- e.g. one hidden entry is read-only -- then he will get an EPERM
+even if permissions seems ok. This is a structural BUG (there's no clean way
+to solve it), and should be fixed.
+
diff --git a/unionfs/COPYING b/unionfs/COPYING
new file mode 100644
index 00000000..5cc9607b
--- /dev/null
+++ b/unionfs/COPYING
@@ -0,0 +1,2 @@
+This program is licensed under the terms of the GNU General Public
+License.
diff --git a/unionfs/CVS/Entries b/unionfs/CVS/Entries
new file mode 100644
index 00000000..6a8e3264
--- /dev/null
+++ b/unionfs/CVS/Entries
@@ -0,0 +1,33 @@
+/AUTHORS/1.2/Mon May 30 12:53:20 2005//
+/BUGS/1.2/Sun Dec  8 14:23:47 2002//
+/CAVEAT/1.1/Wed May 25 01:56:32 2005//
+/COPYING/1.1.1.1/Sat Dec  7 17:47:11 2002//
+/ChangeLog/1.20/Wed Jun 21 19:12:11 2006//
+/Makefile/1.4/Sun May 29 16:37:07 2005//
+/README/1.3/Mon May 30 12:53:20 2005//
+/TODO/1.1.1.1/Sat Dec  7 17:47:11 2002//
+/lib.c/1.9/Wed Jun 21 19:12:11 2006//
+/lib.h/1.5/Sun May 29 16:37:07 2005//
+/lnode.c/1.1.1.1/Sat Dec  7 17:47:11 2002//
+/lnode.h/1.1.1.1/Sat Dec  7 17:47:11 2002//
+/main.c/1.3/Mon Jun 13 00:22:11 2005//
+/ncache.c/1.1.1.1/Sat Dec  7 17:47:11 2002//
+/ncache.h/1.1.1.1/Sat Dec  7 17:47:11 2002//
+/netfs.c/1.6/Thu Jun 30 18:49:55 2005//
+/node.c/1.10/Tue May 31 02:58:48 2005//
+/node.h/1.3/Wed May 25 01:59:48 2005//
+/options.c/1.7/Thu Apr 13 11:06:02 2006//
+/options.h/1.3/Thu Jun 30 18:49:55 2005//
+/pattern.c/1.1/Mon Jan 31 12:30:05 2005//
+/pattern.h/1.1/Mon Jan 31 12:30:05 2005//
+/stow-mutations.h/1.1/Sun May 29 16:37:07 2005//
+/stow-priv.h/1.1/Sun May 29 16:37:07 2005//
+/stow.c/1.5/Thu Jun 30 18:49:55 2005//
+/stow.h/1.2/Sun May 29 16:37:07 2005//
+/ulfs.c/1.5/Thu Apr 13 11:06:02 2006//
+/ulfs.h/1.4/Thu Apr 13 11:06:02 2006//
+/unionfs.h/1.1.1.1/Sat Dec  7 17:47:13 2002//
+/update.c/1.1/Sun May 29 16:37:07 2005//
+/update.h/1.1/Sun May 29 16:37:07 2005//
+/version.h/1.1.1.1/Sat Dec  7 17:47:13 2002//
+D
diff --git a/unionfs/CVS/Repository b/unionfs/CVS/Repository
new file mode 100644
index 00000000..c093c680
--- /dev/null
+++ b/unionfs/CVS/Repository
@@ -0,0 +1 @@
+unionfs
diff --git a/unionfs/CVS/Root b/unionfs/CVS/Root
new file mode 100644
index 00000000..4ca06faf
--- /dev/null
+++ b/unionfs/CVS/Root
@@ -0,0 +1 @@
+:pserver:anonymous@cvs.sv.gnu.org:/sources/hurdextras
diff --git a/unionfs/ChangeLog b/unionfs/ChangeLog
new file mode 100644
index 00000000..d8a29618
--- /dev/null
+++ b/unionfs/ChangeLog
@@ -0,0 +1,229 @@
+2006-06-21  Alfred M. Szmidt  <ams@gnu.org>
+
+	* lib.c (for_each_subdir): Revert previous change.  Reported by
+	Aanjhan Ranganathan <aanjhan@tuxmaniac.com>.
+
+2006-04-13  Ben Asselstine  <benasselstine@gmail.com>
+
+	* options.c (argp_parse_common_options)
+	(argp_parse_startup_options, parsing_startup_options_finished)
+	(argp_common_options, argp_startup_options)
+	(argp_parser_common_options, argp_parser_startup_options)
+	(argp_children_runtime): Make these static.
+	* ulfs.c (ulfs_create, ulfs_destroy, ulfs_install)
+	(ulfs_uninstall, ulfs_get_path): Likewise.
+
+	* ulfs.h (ulfs_get_path): Remove declaration.
+
+	* lib.c (for_each_subdir): Remove unused variables.
+
+2005-06-27  Ben Asselstine  <benasselstine@gmail.com>
+
+	* ulfs.c (ulfs_install): Rewrote to allow insertions of
+	filesystems based on priority.
+	(ulfs_register): Added new argument 'priority'. Set the priority
+	value in ulfs structure.
+	* ulfs.h (ulfs): Added 'priority' field to struct. 
+	Updated ulfs_register declaration.
+	* netfs.c (netfs_append_args): Appending new priority option.
+	* stow.c (stow_privdata): Added 'priority' field to struct.
+	(stow_diradd): Added new 'priority' argument. Fill priority field
+	of 'mypriv'.
+	(_stow_scanstowentry): Changed caller to ulfs_register.
+	(_stow_registermatchingdirs): Likewise.
+	* options.c (arg_common_options): Added entries for OPT_PRIORITY
+	and OPT_ADD.
+	(arg_parse_common_options): Handle OPT_PRIORITY and OPT_ADD
+	case. Renamed 'ulfs_removed' to 'ulfs_mode'. New variable
+	'ulfs_priority'. Changed caller to 'stow_diradd'. Changed caller
+	to 'ulfs_register'.
+	* options.h (OPT_ADD, OPT_PRIORITY, OPT_LONG_ADD)
+	(OPT_LONG_PRIORITY, ULFS_MODE_ADD, ULFS_MODE_REMOVE): New
+	declarations.
+
+2005-06-13  Gianluca Guida  <glguida@gmail.com>
+
+	* main.c (main): Set properly netfs_root_node permissions when
+	underlying node is not a file
+	Reported by Alfred M. Szmidt.
+
+2005-05-31  Gianluca Guida  <glguida@gmail.com>
+
+	* node.c (node_unlink_file): Use lookup to figure out whether a file
+	exists or not, or it will fail on read-only filesystems. 
+	Reported by Ben Asselstine.
+
+2005-05-30  Gianluca Guida  <glguida@gmail.com>
+
+	* AUTHORS: Added myself in the list.
+	* README: Added sections "Introduction" and "Stowing Feature".
+	* options.c (argp_program_bug_address): Changed address.
+
+	* lib.c (for_each_subdir): When call to stat() fails free "name"
+	and continue the loop, instead of returning error. Return 0 at the
+	end of the loop.
+	(for_each_subdir_priv): Likewise.
+
+	* stow.c (_stow_registermatchingdirs): Don't return error when
+	patternlist_match returns false. Free filepath before returning
+	error when ulfs_register fails.
+
+	* ulfs.c (ulfs_register): Removed bogus fprintf.
+	
+2005-05-29  Gianluca Guida  <glguida@gmail.com>
+
+	* Makefile: Added support for building mig stubs for stow feature.
+	(OBJS): Added update.o
+	(unionfs): Added fs_notifyServer.o to final linking.
+	(unionfs.static): Likewise.
+	(fs_notifyServer.o): New rule.
+	(clean): Remove fs_notifyServer.c and fs_notify_S.h when cleaning.
+
+	* netfs.c (OFFSET_T): New macro.
+	(_get_node_size): New function.
+	(netfs_validate_stat): Call _get_node_size for root node.
+
+	* node.c (node_unlink_file): New variable "removed". Return ENOENT
+	if no files unlinked.
+	
+	* ulfs.c: Include "unionfs", fcntl.h and "lib.h".
+	(ulfs_install, ulfs_uninstall): Rewritten.
+	(ulfs_for_each_under_priv, ulfs_check): New function.
+	(ulfs_register): Check that argument is a directory.
+	* ulfs.h: Removed field "prevp" from struct ulfs.
+	(ulfs_check): New declaration.
+	(ulfs_iterate, ulfs_iterate_unlocked): Don't use ulfs_chain_end.
+	* lib.c (check_dir): New function.
+	* lib.h: Added declaration of check_dir.
+	
+	* stow.c: Include "update.h", cthreads.h, hurd/port.h,
+	"stow-priv.h" and "ncache.h".
+	(stow_privdata) Added "lock" to struct. Removed "remove" to
+	struct.
+	(_stow_registermatchingdirs): Removed call to
+	debug_msg_send. Removed call to ulfs_unregister when
+	privdata->remove is set. Return error on ulfs_register failure
+	instead of exiting the program.
+	(_stow_scanstowentry): Removed call to ulfs_unregister when
+	privdata->remove is set. Lock privdata->lock and unlock at end.
+	(stow_port_bucket, stow_port_class): New variables.
+	(_stow_notify_init, begin_using_notify_ports)
+	(end_using_notify_ports, stow_S_file_changed, stow_S_dir_changed)
+	(_stow_notify_thread, stow_init): New functions.
+	(stow_diradd): Allocate "mypriv" instead of using stack.  Call
+	_stow_notify_init.
+	* stow.h: Include "pattern.h".  Declare
+	stow_init.  
+
+	* stow-priv.h: New file.  
+	* stow-mutations.h: Likewise.
+	* update.c: Likewise.
+	* update.h: Likewise.
+
+	* options.c: Include "update.h".
+	(argp_parse_common_options): Check stow_diradd return. Call
+	root_update_schedule instead of node_init_root and ncache_reset
+	when parsing_startup_options_finished is set.
+
+	* main.c: Include "stow.h". Include "update.h".
+	(main): Call stow_init. Call root_update_init.
+
+2005-05-25  Gianluca Guida  <glguida@gmail.com>
+
+	* CAVEAT: New file.
+	* README: Rewritten.
+
+	* netfs.c (netfs_attempt_unlink): Use fshelp_checkdirmod
+	instead of fshelp_access.
+	(netfs_attempt_mkdir): Implemented.
+	(netfs_attempt_rmdir): Likewise.
+	(netfs_attempt_create_file_reduced): Likewise.
+	Fixed typo in a comment.
+	* node.c (node_dir_remove): New function.
+	(node_dir_create): Likewise.
+	* node.h (node_dir_create): New declaration.
+	(node_dir_remove): Likewise.
+
+	* lib.c (for_each_file_priv): Removed unused variables 
+	"name" and "filestat".
+
+2005-05-24  Gianluca Guida  <glguida@gmail.com>
+
+	* netfs.c (netfs_attempt_unlink): Implemented.
+	(netfs_attempt_create_file_reduced): New function.
+	(netfs_S_dir_lookup): Initialized variable "error".
+	Added support for file creation.
+	(netfs_attempt_lookup_improved): Changed instruction flow,
+	return on error not continue on non-error.
+	Check user permission to open file before returning port.
+	* node.c (node_create, node_update, node_lookup_file, node_ulfs_free)
+	(node_ulfs_init, node_entries_get, node_create_root, node_init_root):
+	Changed instruction flow, return on error not continue on non-error.
+	(node_unlink_file): New function.
+	* node.h (node_unlink_file): New declaration.
+	(node_ulfs_iterate_reverse_unlocked): New macro.
+
+	* options.c (argp_parse_common_options): Removed debugging fprintf.
+	
+2005-01-31  Gianluca Guida  <glguida@gmail.com>
+
+	* stow.c (stow_diradd): Handle --stow argument with missing / 
+	correctly.
+
+2005-01-31  Gianluca Guida  <glguida@gmail.com>
+
+	* pattern.c: New file.
+	* stow.c: Likewise.
+	* pattern.h: Likewise.
+	* stow.h: Likewise.
+	* Makefile (OBJS): Added pattern.o and stow.o
+
+	* node.c: Initialize variable err.
+	* lib.c (file_lookup): Initialize variable err.
+	Include <fcntl.h>.
+	(make_filepath, for_each_subdir, for_each_subdir_priv)
+	(for_each_file_priv): New function.
+	* lib.h (make_filepath, for_each_subdir, for_each_subdir_priv): New 
+	declaration.
+	* options.c: Include "pattern.h".
+	Include "stow.h".
+	(arg_common_options): Added entries for OPT_STOW and OPT_PATTERN.
+	(argp_parse_common_options): Handle OPT_STOW and OPT_PATTERN case.
+	* options.h (OPT_PATTERN, OPT_STOW, OPT_LONG_PATTERN, OPT_LONG_STOW): 
+	New declarations.
+	
+2003-07-05  Jeroen Dekkers  <jeroen@dekkers.cx>
+
+	* Makefile: Rewrite.
+
+	* netfs.c (netfs_attempt_create_file): Unlock DIR.
+	(netfs_attempt_mkfile): Likewise.
+
+2002-12-09  Moritz Schulte  <moritz@duesseldorf.ccc.de>
+
+	* lib.h: Fix pointer arg.
+	* lib.c (dir_entries_get): Likewise.
+	* lib.c (dir_entries_get): Fix typo.
+	(dir_entries_get): Change type of data_size to size_t.
+	* node.c (node_entries_get): Change type of dirent_data_size to
+	size_t.
+
+2002-12-08  Moritz Schulte  <moritz@duesseldorf.ccc.de>
+
+	* BUGS: Remove the memory-leak bug.
+	* lib.c: Include <sys/mman.h>.
+	* node.c: Include <sys/mman.h>.
+	(node_entries_get): munmap dirent_data as returned by
+	dir_entries_get.
+	(node_entries_get): New variable: int dirent_data_size.
+	* lib.c (dir_entries_get): New argument: int *dirent_data_size.
+	(dir_entries_get): Do not forget to munmap DATA if something goes
+	wrong.
+	* lib.h: Update dir_entries_get declaration.
+	
+	* node.c (node_create_root): call lnode_destroy, if node_create
+	failed, not if lnode_create failed.  Reported by Richard Smith.
+
+  Copyright 2002, 2003, 2005 Free Software Foundation, Inc.
+  Copying and distribution of this file, with or without modification, are
+  permitted provided the copyright notice and this notice are preserved.
diff --git a/unionfs/Makefile b/unionfs/Makefile
new file mode 100644
index 00000000..b1800722
--- /dev/null
+++ b/unionfs/Makefile
@@ -0,0 +1,81 @@
+# Hurd unionfs
+# Copyright (C) 2001, 2002, 2003, 2005 Free Software Foundation, Inc.
+# Written by Jeroen Dekkers <jeroen@dekkers.cx>.
+# 
+# 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.
+
+CPP = gcc -E -x c
+MIGCOM = mig -cc cat - /dev/null
+
+CFLAGS += -Wall -g -O2 -D_FILE_OFFSET_BITS=64 -std=gnu99 \
+	  -DDEBUG
+LDFLAGS += -lnetfs -lfshelp -liohelp -lthreads \
+           -lports -lihash -lshouldbeinlibc
+OBJS = main.o node.o lnode.o ulfs.o ncache.o netfs.o \
+       lib.o options.o pattern.o stow.o update.o
+
+MIGCOMSFLAGS = -prefix stow_
+fs_notify-MIGSFLAGS = -imacros ./stow-mutations.h
+
+
+# How to build RPC stubs
+
+# We always need this setting, because libc does not include the bogus names.
+MIGCOMFLAGS := -subrprefix __
+
+# User settable variables:
+#	mig-sheader-prefix prepend to foo_S.h for name of foo.defs stub header
+# 	MIGSFLAGS	   flags to CPP when building server stubs and headers
+#	foo-MIGSFLAGS	   same, but only for interface `foo'
+# 	MIGCOMSFLAGS	   flags to MiG when building server stubs and headers
+#	foo-MIGCOMSFLAGS   same, but only for interface `foo'
+# 	MIGUFLAGS	   flags to CPP when building user stubs and headers
+#	foo-MIGUFLAGS	   same, but only for interface `foo'
+# 	MIGCOMUFLAGS	   flags to MiG when building user stubs and headers
+#	foo-MIGCOMUFLAGS   same, but only for interface `foo'
+#	CPPFLAGS	   flags to CPP
+
+# Implicit rules for building server and user stubs from mig .defs files.
+
+# These chained rules could be (and used to be) single rules using pipes.
+# But it's convenient to be able to explicitly make the intermediate
+# files when you want to deal with a problem in the MiG stub generator.
+$(mig-sheader-prefix)%_S.h %Server.c: %.sdefsi
+	$(MIGCOM) $(MIGCOMFLAGS) $(MIGCOMSFLAGS) $($*-MIGCOMSFLAGS) \
+		    -sheader $(mig-sheader-prefix)$*_S.h -server $*Server.c \
+		    -user /dev/null -header /dev/null < $<
+
+%.sdefsi: %.defs
+	$(CPP) $(CPPFLAGS) $(MIGSFLAGS) $($*-MIGSFLAGS) -DSERVERPREFIX=S_ $< -o $@
+
+vpath %.defs $(prefix)/include/hurd
+
+
+
+all: unionfs
+
+unionfs: $(OBJS) fs_notifyServer.o
+	$(CC) -o $@ $(OBJS) fs_notifyServer.o $(LDFLAGS)
+
+unionfs.static: $(OBJS) fs_notifyServer.o
+	$(CC) -static -o $@ $(OBJS) fs_notifyServer.o $(LDFLAGS)
+
+fs_notifyServer.o: fs_notifyServer.c
+
+.PHONY: clean
+
+clean:
+	rm -rf *.o fs_notifyServer.c fs_notify_S.h unionfs
diff --git a/unionfs/README b/unionfs/README
new file mode 100644
index 00000000..1849f4d9
--- /dev/null
+++ b/unionfs/README
@@ -0,0 +1,92 @@
+This is the unionfs translator for the GNU Hurd.
+
+The unionfs translator was originally written by Moritz Schulte 
+<moritz@duesseldorf.ccc.de> and currently mantained by Gianluca Guida 
+<glguida@gmail.com>.
+
+
+
+Introduction.
+
+An unionfs is a filesystems that joins many filesystems into one, meaning
+that you can see into an "unionfs" all files contained in the filesystems 
+that are part of the union.
+
+When two or more directories with the same path are found in different 
+filesystems, their content is joined.
+When two or more files with the same path are found in different filesystems,
+unionfs has to solve this conflict. See below (Internals section) for
+information on what this implementation does in such case.
+
+Example:
+To join "foo/" "bar/" and "baz/" in the directory "quux/", just do:
+
+   settrans -capfg quux/ /hurd/unionfs foo/ bar/ baz/
+
+If you want to join even quux/ contents in the union itself, add -u as a
+translator argument.
+You can add filesystems at run-time with the fsysopts command.
+
+
+
+Stowing feature.
+
+This unionfs implements stowing feature, i.e. the translator will watch a 
+directory, called 'stow', that contains the directories to unite.
+When a directory is added or removed in the stow, it will be added to or 
+removed from the unionfs.
+
+Example:
+To use "/stow" as the stow for the directory "foo/", do:
+
+   settrans -capfg foo/ /hurd/unionfs --stow=/stow
+
+All directories contained in /stow/ will then be joined together in foo/;
+you can delete or add directory at run-time and you will see unionfs adding
+or removing files in foo/ automatically.
+
+Another interesting feature of stow support of unionfs is the pattern matching
+option.
+For example, by using:
+
+   settrans -capfg foo/ /hurd/unionfs -m bar --stow=/stow
+
+You will get joined in foo/ all sub-sub-directories of /stow matching "bar", 
+i.e. /stow/*/bar/; pattern matching will be done too in run-time added stow
+subdirectories.
+Furthermore, you can specify more complex matching pattern to the option, 
+like -m bar\* (to get all stow's sub-sub-directories beginning with "bar")
+or specify multiple -m options.
+
+Example:
+This command
+
+   settrans -capfg /myfaketree/bin -m bin -m sbin --stow=/stow
+
+will join in /myfaketree/bin all files that are in /stow/*/bin and
+/stow/*/sbin. It is equivalent to:
+
+   settrans -capfg /myfaketree/bin -m [s]bin --stow=/stow
+
+
+
+Internals.
+
+This `unionfs' translator is simple, but it is definitely not a joke.
+
+It works by keeping in memory a dynamically updated tree of nodes, each 
+node representing a directory in the unionfs. A node contains an array 
+of ports that give access to the corrisponding directory in the underlying
+filesystems.
+
+On lookup, the first entry found is chosen. Thus, it is very important the
+underlying filesystems ordering, since the first underlying filesystem will
+be the first one to be searched during lookups, and it is the filesystem
+where new files and directories are written into.
+
+At the moment, underlying filesystem ordering is set by option ordering.
+
+See CAVEAT for other unexpected behaviour that could happen.
+
+
+Please send all bug reports to Gianluca Guida <glguida@gmail.com>.
diff --git a/unionfs/TODO b/unionfs/TODO
new file mode 100644
index 00000000..790221f2
--- /dev/null
+++ b/unionfs/TODO
@@ -0,0 +1,7 @@
+Todo list for unionfs:
+
+ * implement filesystem notification support;
+   only update nodes when needed
+ * cache dirents (?)
+ * verify that the locking is correct
+ * increase performance
diff --git a/unionfs/cscope.out b/unionfs/cscope.out
new file mode 100644
index 00000000..74c6b85f
--- /dev/null
+++ b/unionfs/cscope.out
@@ -0,0 +1,39484 @@
+cscope 15 $HOME/Projects/hurd_ssh/hurd/unionfs               0000221091
+	@lib.c
+
+20 

+	#_GNU_SOURCE
+
+
+	)
+
+22 
+	~<hurd/Ãtfs.h
+>
+
+23 
+	~<”rÜ.h
+>
+
+24 
+	~<dœ’t.h
+>
+
+25 
+	~<Ӽo.h
+>
+
+26 
+	~<sys/mmª.h
+>
+
+27 
+	~<¡ddef.h
+>
+
+29 
+	~"lib.h
+"
+
+33 
+mu‹x
+ 
+	gdebug_msg_lock
+ = 
+MUTEX_INITIALIZER
+;
+
+36 
+”rÜ_t
+ 
+	$check_dœ
+ (*
+·th
+)
+
+38 
+¡©
+ 
+fže¡©
+;
+
+39 
+”rÜ_t
+ 
+”r
+ = 0;
+
+41 
+”r
+ = 
+	`¡©
+ (
+·th
+, &
+fže¡©
+);
+
+42 ià(
+”r
+)
+
+43  
+”r
+;
+
+45 ià(!
+	`S_ISDIR
+ (
+fže¡©
+.
+¡_mode
+))
+
+46  
+ENOTDIR
+;
+
+49 
+	}
+}
+
+55 
+”rÜ_t
+
+
+56 
+	$dœ_’Œ›s_g‘
+ (
+fže_t
+ 
+dœ
+, **
+dœ’t_d©a
+,
+
+57 
+size_t
+ *
+dœ’t_d©a_size
+, 
+dœ’t
+ ***
+dœ’t_li¡
+)
+
+59 
+”rÜ_t
+ 
+”r
+;
+
+60 
+size_t
+ 
+d©a_size
+;
+
+61 
+’Œ›s_num
+;
+
+62 *
+d©a
+;
+
+64 
+”r
+ = 
+	`dœ_»addœ
+ (
+dœ
+, &
+d©a
+, &
+d©a_size
+, 0, -1, 0, &
+’Œ›s_num
+);
+
+65 ià(! 
+”r
+)
+
+67 
+dœ’t
+ **
+li¡
+;
+
+69 
+li¡
+ = 
+	`m®loc
+ ( (
+dœ’t
+ *è* (
+’Œ›s_num
+ + 1));
+
+70 ià(
+li¡
+)
+
+72 
+dœ’t
+ *
+dp
+;
+
+73 
+i
+;
+
+75 
+i
+ = 0, 
+dp
+ = (
+dœ’t
+ *è
+d©a
+;
+
+76 
+i
+ < 
+’Œ›s_num
+;
+
+77 
+i
+++, 
+dp
+ = (
+dœ’t
+ *è((*èd°+ dp->
+d_»þ’
+))
+
+78 *(
+li¡
+ + 
+i
+èð
+dp
+;
+
+79 *(
+li¡
+ + 
+i
+èð
+NULL
+;
+
+81 *
+dœ’t_d©a
+ = 
+d©a
+;
+
+82 *
+dœ’t_d©a_size
+ = 
+d©a_size
+;
+
+83 *
+dœ’t_li¡
+ = 
+li¡
+;
+
+87 
+	`munm­
+ (
+d©a
+, 
+d©a_size
+);
+
+88 
+”r
+ = 
+ENOMEM
+;
+
+91  
+”r
+;
+
+92 
+	}
+}
+
+99 
+”rÜ_t
+
+
+100 
+	$fže_lookup
+ (
+fže_t
+ 
+dœ
+, *
+Çme
+, 
+æags0
+, 
+æags1
+,
+
+101 
+mode
+, 
+fže_t
+ *
+pÜt
+, 
+¡©
+ *stat)
+
+103 
+”rÜ_t
+ 
+”r
+ = 0;
+
+104 
+fže_t
+ 
+p
+;
+
+105 
+¡©
+ 
+s
+;
+
+107 
+fže_t
+ 
+	`do_fže_lookup
+ (fže_ˆ
+d
+, *
+n
+, 
+f
+, 
+m
+)
+
+109 ià(
+	`pÜt_v®id
+ (
+d
+))
+
+110 
+p
+ = 
+	`fže_Çme_lookup_und”
+ (
+d
+, 
+n
+, 
+f
+, 
+m
+);
+
+111 ià(
+Ӽo
+ =ð
+EACCES
+)
+
+112 
+p
+ = 
+	`fže_Çme_lookup
+ (
+n
+, 
+f
+, 
+m
+);
+
+113  
+p
+;
+
+116 
+p
+ = 
+	`do_fže_lookup
+ (
+dœ
+, 
+Çme
+, 
+æags0
+, 
+mode
+);
+
+117 ià(! 
+	`pÜt_v®id
+ (
+p
+))
+
+118 
+p
+ = 
+	`do_fže_lookup
+ (
+dœ
+, 
+Çme
+, 
+æags1
+, 
+mode
+);
+
+120 ià(
+	`pÜt_v®id
+ (
+p
+))
+
+122 ià(
+¡©
+)
+
+124 
+”r
+ = 
+	`io_¡©
+ (
+p
+, &
+s
+);
+
+125 ià(
+”r
+)
+
+126 
+	`pÜt_d—Îoc
+ (
+p
+);
+
+130 
+”r
+ = 
+Ӽo
+;
+
+132 ià(! 
+”r
+)
+
+134 *
+pÜt
+ = 
+p
+;
+
+135 ià(
+¡©
+)
+
+136 *
+¡©
+ = 
+s
+;
+
+138  
+”r
+;
+
+139 
+	}
+}
+
+141 
+	~<fúŽ.h
+>
+
+144 
+	$make_fž•©h
+ (*
+·th
+, *
+fž’ame
+)
+
+146 
+Ëngth
+;
+
+147 *
+fž•©h
+;
+
+149 
+Ëngth
+ = 
+	`¡¾’
+ (
+·th
+è+ sŒËÀ(
+fž’ame
+) + 2;
+
+150 
+fž•©h
+ = 
+	`m®loc
+ (
+Ëngth
+);
+
+151 ià(
+fž•©h
+ =ð
+NULL
+)
+
+152  
+NULL
+;
+
+154 
+	`¡ºýy
+ (
+fž•©h
+, 
+·th
+, 
+Ëngth
+);
+
+155 
+	`¡ºÿt
+ (
+fž•©h
+, 
+fž’ame
+, 
+	`¡¾’
+ (filename));
+
+157  
+fž•©h
+;
+
+158 
+	}
+}
+
+160 
+”rÜ_t
+
+
+161 
+fÜ_—ch_subdœ
+ (*
+·th
+, 
+	$”rÜ_t
+ (*
+func
+) (*, *))
+
+163 
+dœ’t
+ **dœ’t, **
+dœ’t_li¡
+;
+
+164 *
+dœ’t_d©a
+;
+
+165 
+size_t
+ 
+dœ’t_d©a_size
+;
+
+166 
+fže_t
+ 
+dœ
+;
+
+167 
+”rÜ_t
+ 
+”r
+;
+
+169 
+dœ
+ = 
+	`fže_Çme_lookup
+ (
+·th
+, 
+O_READ
+, 0);
+
+171 
+”r
+ = 
+	`dœ_’Œ›s_g‘
+ (
+dœ
+, &
+dœ’t_d©a
+, &
+dœ’t_d©a_size
+, &
+dœ’t_li¡
+);
+
+172 ià(
+”r
+)
+
+173  
+”r
+;
+
+175 
+dœ’t
+ = 
+dœ’t_li¡
+; (! 
+”r
+) && (*dirent); dirent++)
+
+177 *
+Çme
+;
+
+178 
+¡©
+ 
+fže¡©
+;
+
+180 ià((!
+	`¡rcmp
+ ((*
+dœ’t
+)->
+d_Çme
+, "."))
+
+181 || (!
+	`¡rcmp
+ ((*
+dœ’t
+)->
+d_Çme
+, "..")))
+
+184 
+Çme
+ = 
+	`make_fž•©h
+ (
+·th
+, (*
+dœ’t
+)->
+d_Çme
+);
+
+186 
+”r
+ = 
+	`¡©
+ (
+Çme
+, &
+fže¡©
+);
+
+188 
+	`ä“
+ (
+Çme
+);
+
+190 ià(
+”r
+)
+
+192 
+	`årštf
+ (
+¡d”r
+, "unionfs: couldn't stat %s%s\n",
+
+193 
+·th
+, (*
+dœ’t
+)->
+d_Çme
+);
+
+197 ià(!
+	`S_ISDIR
+(
+fže¡©
+.
+¡_mode
+))
+
+200 
+	`func
+ ((*
+dœ’t
+)->
+d_Çme
+, 
+·th
+);
+
+204 
+	}
+}
+
+206 
+”rÜ_t
+
+
+207 
+fÜ_—ch_subdœ_´iv
+ (*
+·th
+, 
+	$”rÜ_t
+ (*
+func
+) (*, *, *),
+
+208 *
+´iv
+)
+
+210 
+dœ’t
+ **dœ’t, **
+dœ’t_li¡
+;
+
+211 *
+dœ’t_d©a
+;
+
+212 
+size_t
+ 
+dœ’t_d©a_size
+;
+
+213 
+fže_t
+ 
+dœ
+;
+
+214 
+”rÜ_t
+ 
+”r
+;
+
+216 
+dœ
+ = 
+	`fže_Çme_lookup
+ (
+·th
+, 
+O_READ
+, 0);
+
+218 
+”r
+ = 
+	`dœ_’Œ›s_g‘
+ (
+dœ
+, &
+dœ’t_d©a
+, &
+dœ’t_d©a_size
+, &
+dœ’t_li¡
+);
+
+219 ià(
+”r
+)
+
+220  
+”r
+;
+
+222 
+dœ’t
+ = 
+dœ’t_li¡
+; (!
+”r
+) && (*dirent); dirent++)
+
+224 *
+Çme
+;
+
+225 
+¡©
+ 
+fže¡©
+;
+
+227 ià((!
+	`¡rcmp
+ ((*
+dœ’t
+)->
+d_Çme
+, "."))
+
+228 || (!
+	`¡rcmp
+ ((*
+dœ’t
+)->
+d_Çme
+, "..")))
+
+231 
+Çme
+ = 
+	`make_fž•©h
+ (
+·th
+, (*
+dœ’t
+)->
+d_Çme
+);
+
+233 
+”r
+ = 
+	`¡©
+ (
+Çme
+, &
+fže¡©
+);
+
+235 
+	`ä“
+ (
+Çme
+);
+
+237 ià(
+”r
+)
+
+239 
+	`årštf
+ (
+¡d”r
+, "unionfs: couldn't stat %s%s\n",
+
+240 
+·th
+, (*
+dœ’t
+)->
+d_Çme
+);
+
+244 ià(!
+	`S_ISDIR
+(
+fže¡©
+.
+¡_mode
+))
+
+247 
+	`func
+ ((*
+dœ’t
+)->
+d_Çme
+, 
+·th
+, 
+´iv
+);
+
+251 
+	}
+}
+
+253 
+”rÜ_t
+
+
+254 
+fÜ_—ch_fže_´iv
+ (*
+·th
+, 
+	$”rÜ_t
+ (*
+func
+) (*, *, *),
+
+255 *
+´iv
+)
+
+257 
+dœ’t
+ **dœ’t, **
+dœ’t_li¡
+;
+
+258 *
+dœ’t_d©a
+;
+
+259 
+size_t
+ 
+dœ’t_d©a_size
+;
+
+260 
+fže_t
+ 
+dœ
+;
+
+261 
+”rÜ_t
+ 
+”r
+;
+
+263 
+dœ
+ = 
+	`fže_Çme_lookup
+ (
+·th
+, 
+O_READ
+, 0);
+
+265 
+”r
+ = 
+	`dœ_’Œ›s_g‘
+ (
+dœ
+, &
+dœ’t_d©a
+, &
+dœ’t_d©a_size
+, &
+dœ’t_li¡
+);
+
+266 ià(
+”r
+)
+
+267  
+”r
+;
+
+269 
+dœ’t
+ = 
+dœ’t_li¡
+; (!
+”r
+) && (*dirent); dirent++)
+
+272 ià((!
+	`¡rcmp
+ ((*
+dœ’t
+)->
+d_Çme
+, "."))
+
+273 || (!
+	`¡rcmp
+ ((*
+dœ’t
+)->
+d_Çme
+, "..")))
+
+276 
+	`func
+ ((*
+dœ’t
+)->
+d_Çme
+, 
+·th
+, 
+´iv
+);
+
+279  
+”r
+;
+
+280 
+	}
+}
+
+	@lib.h
+
+20 #iâdeà
+INCLUDED_LIB_H
+
+
+21 

+	#INCLUDED_LIB_H
+
+
+	)
+
+23 
+	~<hurd.h
+>
+
+24 
+	~<dœ’t.h
+>
+
+25 
+	~<¡ddef.h
+>
+
+29 

+	#DIRENT_ALIGN
+ 4
+
+	)
+
+30 

+	#DIRENT_NAME_OFFS
+ 
+	`off£tof
+ (
+dœ’t
+, 
+d_Çme
+)
+
+	)
+
+34 

+	#DIRENT_LEN
+(
+Çme_Ën
+) \
+
+35 ((
+DIRENT_NAME_OFFS
+ + (
+Çme_Ën
+è+ 1 + (
+DIRENT_ALIGN
+ - 1)) \
+
+36 & ~(
+DIRENT_ALIGN
+ - 1))
+
+	)
+
+40 

+	#pÜt_nuÎ
+ 
+MACH_PORT_NULL
+
+
+	)
+
+41 

+	#pÜt_d—Îoc
+(
+p
+è
+	`mach_pÜt_d—Îoÿ‹
+ (
+	`mach_�sk_£lf
+ (), (p))
+
+	)
+
+42 

+	#pÜt_v®id
+(
+p
+è(Õè!ð
+pÜt_nuÎ
+)
+
+	)
+
+48 
+”rÜ_t
+ 
+dœ_’Œ›s_g‘
+ (
+fže_t
+ 
+dœ
+, **
+dœ’t_d©a
+,
+
+49 
+size_t
+ *
+dœ’t_d©a_size
+,
+
+50 
+dœ’t
+ ***
+dœ’t_li¡
+);
+
+52 *
+make_fž•©h
+ (*, *);
+
+53 
+”rÜ_t
+ 
+fÜ_—ch_subdœ
+ (*, 
+	$”rÜ_t
+ (*) (*, *));
+
+54 
+”rÜ_t
+ 
+	`fÜ_—ch_subdœ_´iv
+ (*, 
+	$”rÜ_t
+ (*) (*, *, *),
+
+62 
+”rÜ_t
+ 
+	`fže_lookup
+ (
+fže_t
+ 
+dœ
+, *
+Çme
+, 
+æags0
+, 
+æags1
+, 
+mode
+,
+
+63 
+fže_t
+ *
+pÜt
+, 
+¡©
+ *stat);
+
+66 
+”rÜ_t
+ 
+	`check_dœ
+ (*
+·th
+);
+
+68 

+mu‹x
+ 
+debug_msg_lock
+;
+
+71 

+	#debug_msg_£nd
+(
+fmt
+, 
+¬gs
+...) \
+
+74 
+	`mu‹x_lock
+ (&
+debug_msg_lock
+); \
+
+75 
+	`årštf
+ (
+¡d”r
+, "%s:%i: ", 
+__FILE__
+, 
+__LINE__
+); \
+
+76 
+	`årštf
+ (
+¡d”r
+, 
+fmt
+ , ## 
+¬gs
+); \
+
+77 
+	`putc
+ ('\n', 
+¡d”r
+); \
+
+78 
+	`mu‹x_uÆock
+ (&
+debug_msg_lock
+); \
+
+79 
+	}
+} \
+
+80 0)
+
+	)
+
+	@lnode.c
+
+23 

+	#_GNU_SOURCE
+
+
+	)
+
+25 
+	~<hurd/Ãtfs.h
+>
+
+26 
+	~<”rÜ.h
+>
+
+27 
+	~<¡dlib.h
+>
+
+28 
+	~<¡ršg.h
+>
+
+30 
+	~"Êode.h
+"
+
+31 
+	~"lib.h
+"
+
+32 
+	~"uniÚfs.h
+"
+
+37 
+”rÜ_t
+
+
+38 
+	$Êode_ü—‹
+ (*
+Çme
+, 
+Êode_t
+ **
+node
+)
+
+40 
+Êode_t
+ *
+node_Ãw
+ = 
+	`m®loc
+ ( (lnode_t));
+
+41 
+”rÜ_t
+ 
+”r
+ = 0;
+
+43 
+	`debug_msg
+ ("Êode_ü—‹ fÜ‚ame: %s", 
+Çme
+);
+
+45 ià(! 
+node_Ãw
+)
+
+46 
+”r
+ = 
+ENOMEM
+;
+
+49 *
+Çme_ý
+ = 
+NULL
+;
+
+51 ià(
+Çme
+)
+
+52 
+Çme_ý
+ = 
+	`¡rdup
+ (
+Çme
+);
+
+53 ià(
+Çme
+ && (! 
+Çme_ý
+))
+
+55 
+”r
+ = 
+ENOMEM
+;
+
+56 
+	`ä“
+ (
+node_Ãw
+);
+
+60 
+node_Ãw
+->
+Çme
+ = 
+Çme_ý
+;
+
+61 
+node_Ãw
+->
+Çme_Ën
+ = 
+Çme_ý
+ ? 
+	`¡¾’
+ (name_cp) : 0;
+
+62 
+node_Ãw
+->
+æags
+ = 0;
+
+63 
+node_Ãw
+->
+node
+ = 
+NULL
+;
+
+64 
+node_Ãw
+->
+Ãxt
+ = 
+NULL
+;
+
+65 
+node_Ãw
+->
+´evp
+ = 
+NULL
+;
+
+66 
+node_Ãw
+->
+dœ
+ = 
+NULL
+;
+
+67 
+node_Ãw
+->
+’Œ›s
+ = 
+NULL
+;
+
+68 
+node_Ãw
+->
+»ã»nûs
+ = 1;
+
+69 
+	`mu‹x_š™
+ (&
+node_Ãw
+->
+lock
+);
+
+70 
+	`mu‹x_lock
+ (&
+node_Ãw
+->
+lock
+);
+
+71 *
+node
+ = 
+node_Ãw
+;
+
+74  
+”r
+;
+
+75 
+	}
+}
+
+79 
+	$Êode_de¡roy
+ (
+Êode_t
+ *
+node
+)
+
+81 
+	`debug_msg
+ ("Êode_de¡roy fÜ‚ame: %s", 
+node
+->
+Çme
+);
+
+82 
+	`ä“
+ (
+node
+->
+Çme
+);
+
+83 
+	`ä“
+ (
+node
+);
+
+84 
+	}
+}
+
+89 
+	$Êode_š¡®l
+ (
+Êode_t
+ *
+dœ
+,†node_ˆ*
+node
+)
+
+91 
+	`Êode_»f_add
+ (
+dœ
+);
+
+92 
+node
+->
+Ãxt
+ = 
+dœ
+->
+’Œ›s
+;
+
+93 
+node
+->
+´evp
+ = &
+dœ
+->
+’Œ›s
+;
+
+94 ià(
+dœ
+->
+’Œ›s
+)
+
+95 
+dœ
+->
+’Œ›s
+->
+´evp
+ = &
+node
+->
+Ãxt
+;
+
+96 
+dœ
+->
+’Œ›s
+ = 
+node
+;
+
+97 
+node
+->
+dœ
+ = dir;
+
+98 
+	}
+}
+
+103 
+	$Êode_unš¡®l
+ (
+Êode_t
+ *
+node
+)
+
+105 
+	`Êode_»f_»move
+ (
+node
+->
+dœ
+);
+
+106 *
+node
+->
+´evp
+ =‚ode->
+Ãxt
+;
+
+107 ià(
+node
+->
+Ãxt
+)
+
+108 
+node
+->
+Ãxt
+->
+´evp
+ = &node->next;
+
+109 
+	}
+}
+
+113 
+	$Êode_»f_add
+ (
+Êode_t
+ *
+node
+)
+
+115 
+node
+->
+»ã»nûs
+++;
+
+116 
+	}
+}
+
+121 
+	$Êode_»f_»move
+ (
+Êode_t
+ *
+node
+)
+
+123 
+	`as£¹
+ (
+node
+->
+»ã»nûs
+);
+
+124 ià(! --
+node
+->
+»ã»nûs
+)
+
+126 
+	`Êode_unš¡®l
+ (
+node
+);
+
+127 
+	`Êode_de¡roy
+ (
+node
+);
+
+130 
+	`mu‹x_uÆock
+ (&
+node
+->
+lock
+);
+
+131 
+	}
+}
+
+135 
+”rÜ_t
+
+
+136 
+	$Êode_g‘
+ (
+Êode_t
+ *
+dœ
+, *
+Çme
+,
+
+137 
+Êode_t
+ **
+node
+)
+
+139 
+”rÜ_t
+ 
+”r
+ = 0;
+
+140 
+Êode_t
+ *
+n
+;
+
+142 
+n
+ = 
+dœ
+->
+’Œ›s
+;‚ && 
+	`¡rcmp
+ (n->
+Çme
+,‚ame);‚ =‚->
+Ãxt
+);
+
+143 ià(
+n
+)
+
+145 
+	`mu‹x_lock
+ (&
+n
+->
+lock
+);
+
+146 
+	`Êode_»f_add
+ (
+n
+);
+
+147 *
+node
+ = 
+n
+;
+
+150 
+”r
+ = 
+ENOENT
+;
+
+152  
+”r
+;
+
+153 
+	}
+}
+
+156 
+”rÜ_t
+
+
+157 
+	$Êode_·th_cÚ¡ruù
+ (
+Êode_t
+ *
+node
+,
+
+158 **
+·th
+)
+
+160 
+”rÜ_t
+ 
+”r
+ = 0;
+
+161 
+p_Ën
+ = 1;
+
+162 
+Êode_t
+ *
+n
+;
+
+163 *
+p
+;
+
+165 
+n
+ = 
+node
+;‚ &&‚->
+dœ
+;‚ =‚->dir)
+
+166 
+p_Ën
+ +ð
+n
+->
+Çme_Ën
+ + (n->
+dœ
+->dir ? 1 : 0);
+
+168 
+p
+ = 
+	`m®loc
+ (
+p_Ën
+);
+
+169 ià(! 
+p
+)
+
+170 
+”r
+ = 
+ENOMEM
+;
+
+173 *(
+p
+ + --
+p_Ën
+) = 0;
+
+174 
+n
+ = 
+node
+;‚ &&‚->
+dœ
+;‚ =‚->dir)
+
+176 
+p_Ën
+ -ð
+n
+->
+Çme_Ën
+;
+
+177 
+	`¡ºýy
+ (
+p
+ + 
+p_Ën
+, 
+n
+->
+Çme
+,‚->
+Çme_Ën
+);
+
+178 ià(
+n
+->
+dœ
+->dir)
+
+179 *(
+p
+ + --
+p_Ën
+) = '/';
+
+181 *
+·th
+ = 
+p
+;
+
+183  
+”r
+;
+
+184 
+	}
+}
+
+	@lnode.h
+
+22 #iâdeà
+INCLUDED_LNODE_H
+
+
+23 

+	#INCLUDED_LNODE_H
+
+
+	)
+
+25 
+	~<hurd/Ãtfs.h
+>
+
+26 
+	~<”rÜ.h
+>
+
+28 
+	sÊode
+
+
+30 *
+	mÇme
+;
+
+31 
+	mÇme_Ën
+;
+
+34 
+	mæags
+;
+
+35 
+	m»ã»nûs
+;
+
+36 
+node
+ *
+	mnode
+;
+
+37 
+Êode
+ *
+	mÃxt
+, **
+	m´evp
+;
+
+39 
+Êode
+ *
+	mdœ
+;
+
+41 
+Êode
+ *
+	m’Œ›s
+;
+
+43 
+mu‹x
+ 
+	mlock
+;
+
+45 
+Êode
+ 
+	tÊode_t
+;
+
+50 
+”rÜ_t
+ 
+Êode_ü—‹
+ (*
+Çme
+, 
+Êode_t
+ **
+node
+);
+
+53 
+Êode_de¡roy
+ (
+Êode_t
+ *
+node
+);
+
+56 
+Êode_š¡®l
+ (
+Êode_t
+ *
+dœ
+,†node_ˆ*
+node
+);
+
+60 
+Êode_unš¡®l
+ (
+Êode_t
+ *
+node
+);
+
+63 
+Êode_»f_add
+ (
+Êode_t
+ *
+node
+);
+
+67 
+Êode_»f_»move
+ (
+Êode_t
+ *
+node
+);
+
+71 
+”rÜ_t
+ 
+Êode_g‘
+ (
+Êode_t
+ *
+dœ
+, *
+Çme
+,
+
+72 
+Êode_t
+ **
+node
+);
+
+75 
+”rÜ_t
+ 
+Êode_·th_cÚ¡ruù
+ (
+Êode_t
+ *
+node
+, **
+·th
+);
+
+	@main.c
+
+20 

+	#_GNU_SOURCE
+
+
+	)
+
+22 
+	~<hurd/Ãtfs.h
+>
+
+23 
+	~<¬gp.h
+>
+
+24 
+	~<¬gz.h
+>
+
+25 
+	~<”rÜ.h
+>
+
+26 
+	~<fúŽ.h
+>
+
+27 
+	~<sys/ty³s.h
+>
+
+28 
+	~<uni¡d.h
+>
+
+30 
+	~"v”siÚ.h
+"
+
+31 
+	~"uniÚfs.h
+"
+
+32 
+	~"nÿche.h
+"
+
+33 
+	~"ulfs.h
+"
+
+34 
+	~"Êode.h
+"
+
+35 
+	~"node.h
+"
+
+36 
+	~"ÝtiÚs.h
+"
+
+37 
+	~"¡ow.h
+"
+
+38 
+	~"upd©e.h
+"
+
+40 *
+	gÃtfs_£rv”_Çme
+ = "unionfs";
+
+41 *
+	gÃtfs_£rv”_v”siÚ
+ = 
+HURD_VERSION
+;
+
+44 
+	gÃtfs_maxsymlšks
+ = 0;
+
+47 
+	guniÚfs_æags
+;
+
+50 
+pid_t
+ 
+	gfsid
+;
+
+53 
+mach_pÜt_t
+ 
+	gund”lyšg_node
+;
+
+56 
+¡©
+ 
+	gund”lyšg_node_¡©
+;
+
+59 vÞ©ž�
+m­³d_time_v®ue
+ *
+	gm­time
+;
+
+62 
+¬gp
+ *
+	gÃtfs_ruÁime_¬gp
+ = &
+¬gp_ruÁime
+;
+
+66 
+	$maš
+ (
+¬gc
+, **
+¬gv
+)
+
+68 
+mach_pÜt_t
+ 
+boÙ¡¿p_pÜt
+;
+
+69 
+”rÜ_t
+ 
+”r
+ = 0;
+
+71 
+	`roÙ_upd©e_š™
+ ();
+
+73 
+”r
+ = 
+	`¡ow_š™
+();
+
+74 ià(
+”r
+)
+
+75 
+	`”rÜ
+ (
+EXIT_FAILURE
+, 
+”r
+, "failed�o initialize stow support");
+
+78 
+	`¬gp_·r£
+ (&
+¬gp_¡¬tup
+, 
+¬gc
+, 
+¬gv
+, 
+ARGP_IN_ORDER
+, 0, 0);
+
+80 
+”r
+ = 
+	`node_ü—‹_roÙ
+ (&
+Ãtfs_roÙ_node
+);
+
+81 ià(
+”r
+)
+
+82 
+	`”rÜ
+ (
+EXIT_FAILURE
+, 
+”r
+, "failed�o create„oot‚ode");
+
+85 
+	`�sk_g‘_boÙ¡¿p_pÜt
+ (
+	`mach_�sk_£lf
+ (), &
+boÙ¡¿p_pÜt
+);
+
+86 
+	`Ãtfs_š™
+ ();
+
+87 
+und”lyšg_node
+ = 
+	`Ãtfs_¡¬tup
+ (
+boÙ¡¿p_pÜt
+, 
+O_READ
+);
+
+89 
+”r
+ = 
+	`node_š™_roÙ
+ (
+Ãtfs_roÙ_node
+);
+
+90 ià(
+”r
+)
+
+91 
+	`”rÜ
+ (
+EXIT_FAILURE
+, 
+”r
+, "failed�o initialize„oot‚ode");
+
+94 
+”r
+ = 
+	`m­time_m­
+ (0, 0, &
+m­time
+);
+
+95 ià(
+”r
+)
+
+96 
+	`”rÜ
+ (
+EXIT_FAILURE
+, 
+”r
+, "maptime_map");
+
+99 
+	`nÿche_š™
+ (
+nÿche_size
+);
+
+102 
+”r
+ = 
+	`io_¡©
+ (
+und”lyšg_node
+, &
+und”lyšg_node_¡©
+);
+
+104 ià(
+”r
+)
+
+105 
+	`”rÜ
+ (
+EXIT_FAILURE
+, 
+”r
+, "io_stat");
+
+107 
+fsid
+ = 
+	`g‘pid
+ ();
+
+108 
+Ãtfs_roÙ_node
+->
+Â_¡©
+ = 
+und”lyšg_node_¡©
+;
+
+109 
+Ãtfs_roÙ_node
+->
+Â_¡©
+.
+¡_šo
+ = 
+UNIONFS_ROOT_INODE
+;
+
+110 
+Ãtfs_roÙ_node
+->
+Â_¡©
+.
+¡_fsid
+ = 
+fsid
+;
+
+111 
+Ãtfs_roÙ_node
+->
+Â_¡©
+.
+¡_mode
+ = 
+S_IFDIR
+ | (
+und”lyšg_node_¡©
+.st_mode
+
+112 & ~
+S_IFMT
+ & ~
+S_ITRANS
+);
+
+113 
+Ãtfs_roÙ_node
+->
+Â_Œª¦©ed
+ =‚‘fs_roÙ_node->
+Â_¡©
+.
+¡_mode
+;
+
+117 ià(! 
+	`S_ISDIR
+ (
+und”lyšg_node_¡©
+.
+¡_mode
+))
+
+119 ià(
+und”lyšg_node_¡©
+.
+¡_mode
+ & 
+S_IRUSR
+)
+
+120 
+Ãtfs_roÙ_node
+->
+Â_¡©
+.
+¡_mode
+ |ð
+S_IXUSR
+;
+
+121 ià(
+und”lyšg_node_¡©
+.
+¡_mode
+ & 
+S_IRGRP
+)
+
+122 
+Ãtfs_roÙ_node
+->
+Â_¡©
+.
+¡_mode
+ |ð
+S_IXGRP
+;
+
+123 ià(
+und”lyšg_node_¡©
+.
+¡_mode
+ & 
+S_IROTH
+)
+
+124 
+Ãtfs_roÙ_node
+->
+Â_¡©
+.
+¡_mode
+ |ð
+S_IXOTH
+;
+
+128 
+	`fsh–p_touch
+ (&
+Ãtfs_roÙ_node
+->
+Â_¡©
+,
+
+129 
+TOUCH_ATIME
+ | 
+TOUCH_MTIME
+ | 
+TOUCH_CTIME
+, 
+m­time
+);
+
+133 
+	`Ãtfs_£rv”_loÝ
+ ();
+
+134 
+	}
+}
+
+	@ncache.c
+
+20 

+	#_GNU_SOURCE
+
+
+	)
+
+22 
+	~<hurd/Ãtfs.h
+>
+
+23 
+	~<”rÜ.h
+>
+
+24 
+	~<¡dlib.h
+>
+
+25 
+	~<as£¹.h
+>
+
+27 
+	~"nÿche.h
+"
+
+28 
+	~"lib.h
+"
+
+29 
+	~"uniÚfs.h
+"
+
+32 
+nÿche_t
+ 
+	gnÿche
+;
+
+35 
+	gnÿche_size
+ = 
+NCACHE_SIZE
+;
+
+40 
+	$nÿche_š™
+ (
+size_max
+)
+
+42 
+nÿche
+.
+mru
+ = 
+NULL
+;
+
+43 
+nÿche
+.
+Ìu
+ = 
+NULL
+;
+
+44 
+nÿche
+.
+size_max
+ = size_max;
+
+45 
+nÿche
+.
+size_cu¼’t
+ = 0;
+
+46 
+	`mu‹x_š™
+ (&
+nÿche
+.
+lock
+);
+
+47 
+	}
+}
+
+51 
+	$nÿche_node_»move
+ (
+node_t
+ *
+node
+)
+
+53 
+Êode
+ *
+Â
+ = 
+node
+->nn;
+
+55 ià(
+Â
+->
+nÿche_Ãxt
+)
+
+56 
+Â
+->
+nÿche_Ãxt
+->Â->
+nÿche_´ev
+ =‚n->ncache_prev;
+
+57 ià(
+Â
+->
+nÿche_´ev
+)
+
+58 
+Â
+->
+nÿche_´ev
+->Â->
+nÿche_Ãxt
+ =‚n->ncache_next;
+
+59 ià(
+nÿche
+.
+mru
+ =ð
+node
+)
+
+60 
+nÿche
+.
+mru
+ = 
+Â
+->
+nÿche_Ãxt
+;
+
+61 ià(
+nÿche
+.
+Ìu
+ =ð
+node
+)
+
+62 
+nÿche
+.
+Ìu
+ = 
+Â
+->
+nÿche_´ev
+;
+
+63 
+Â
+->
+nÿche_Ãxt
+ = 
+NULL
+;
+
+64 
+Â
+->
+nÿche_´ev
+ = 
+NULL
+;
+
+65 
+nÿche
+.
+size_cu¼’t
+--;
+
+66 
+	}
+}
+
+69 
+	$nÿche_»£t
+ ()
+
+71 
+node_t
+ *
+node
+;
+
+73 
+	`mu‹x_lock
+ (&
+nÿche
+.
+lock
+);
+
+74 (
+node
+ = 
+nÿche
+.
+mru
+))
+
+75 
+	`nÿche_node_»move
+ (
+node
+);
+
+76 
+	`mu‹x_uÆock
+ (&
+nÿche
+.
+lock
+);
+
+77 
+	}
+}
+
+82 
+”rÜ_t
+
+
+83 
+	$nÿche_node_lookup
+ (
+Êode_t
+ *
+Êode
+, 
+node_t
+ **
+node
+)
+
+85 
+”rÜ_t
+ 
+”r
+ = 0;
+
+86 
+node_t
+ *
+n
+;
+
+88 ià(
+Êode
+->
+node
+)
+
+90 
+	`debug_msg
+ ("ncache_node_lookup for†node: %s (found in cache)",
+
+91 
+Êode
+->
+Çme
+);
+
+92 
+n
+ = 
+Êode
+->
+node
+;
+
+93 
+	`Ãtfs_Äef
+ (
+n
+);
+
+97 
+	`debug_msg
+ ("ncache_node_lookup for†node: %s (newly created)",
+
+98 
+Êode
+->
+Çme
+);
+
+99 
+”r
+ = 
+	`node_ü—‹
+ (
+Êode
+, &
+n
+);
+
+102 ià(! 
+”r
+)
+
+104 
+	`mu‹x_lock
+ (&
+n
+->
+lock
+);
+
+105 *
+node
+ = 
+n
+;
+
+107  
+”r
+;
+
+108 
+	}
+}
+
+113 
+	$nÿche_node_add
+ (
+node_t
+ *
+node
+)
+
+115 
+	`mu‹x_lock
+ (&
+nÿche
+.
+lock
+);
+
+117 
+	`debug_msg
+ ("addšg‚od�tØÿche: %s", 
+node
+->
+Â
+->
+Êode
+->
+Çme
+);
+
+119 ià(
+nÿche
+.
+size_max
+ > 0 ||‚ÿche.
+size_cu¼’t
+ > 0)
+
+121 ià(
+nÿche
+.
+mru
+ !ð
+node
+)
+
+123 ià(
+node
+->
+Â
+->
+nÿche_Ãxt
+ ||‚ode->Â->
+nÿche_´ev
+)
+
+125 
+	`nÿche_node_»move
+ (
+node
+);
+
+128 
+	`Ãtfs_Äef
+ (
+node
+);
+
+130 
+node
+->
+Â
+->
+nÿche_Ãxt
+ = 
+nÿche
+.
+mru
+;
+
+131 
+node
+->
+Â
+->
+nÿche_´ev
+ = 
+NULL
+;
+
+132 ià(
+nÿche
+.
+mru
+)
+
+133 
+nÿche
+.
+mru
+->
+Â
+->
+nÿche_´ev
+ = 
+node
+;
+
+134 ià(! 
+nÿche
+.
+Ìu
+)
+
+135 
+nÿche
+.
+Ìu
+ = 
+node
+;
+
+136 
+nÿche
+.
+mru
+ = 
+node
+;
+
+137 
+nÿche
+.
+size_cu¼’t
+++;
+
+142 
+nÿche
+.
+size_cu¼’t
+ >‚ÿche.
+size_max
+)
+
+144 
+node
+ *
+Ìu
+ = 
+nÿche
+.lru;
+
+145 
+	`debug_msg
+ ("»movšg cached‚ode: %s", 
+Ìu
+->
+Â
+->
+Êode
+->
+Çme
+);
+
+146 
+	`nÿche_node_»move
+ (
+Ìu
+);
+
+147 
+	`Ãtfs_Ä–e
+ (
+Ìu
+);
+
+150 
+	`mu‹x_uÆock
+ (&
+nÿche
+.
+lock
+);
+
+151 
+	}
+}
+
+	@ncache.h
+
+20 #iâdeà
+INCLUDED_NCACHE_H
+
+
+21 

+	#INCLUDED_NCACHE_H
+
+
+	)
+
+23 
+	~<”rÜ.h
+>
+
+24 
+	~<hurd/Ãtfs.h
+>
+
+26 
+	~"node.h
+"
+
+28 
+	snÿche
+
+
+30 
+node_t
+ *
+	mmru
+;
+
+32 
+node_t
+ *
+	mÌu
+;
+
+34 
+	msize_max
+;
+
+36 
+	msize_cu¼’t
+;
+
+38 
+mu‹x
+ 
+	mlock
+;
+
+39 } 
+	tnÿche_t
+;
+
+42 

+nÿche_size
+;
+
+46 
+nÿche_š™
+ (
+size_max
+);
+
+51 
+”rÜ_t
+ 
+nÿche_node_lookup
+ (
+Êode_t
+ *
+Êode
+, 
+node_t
+ **
+node
+);
+
+53 
+nÿche_»£t
+ ();
+
+57 
+nÿche_node_add
+ (
+node_t
+ *
+node
+);
+
+	@netfs.c
+
+20 

+	#_GNU_SOURCE
+
+
+	)
+
+22 
+	~<hurd/Ãtfs.h
+>
+
+23 
+	~<”rÜ.h
+>
+
+24 
+	~<¬gz.h
+>
+
+25 
+	~<¡ddef.h
+>
+
+26 
+	~<fúŽ.h
+>
+
+27 
+	~<as£¹.h
+>
+
+28 
+	~<¡ršg.h
+>
+
+29 
+	~<¡dio.h
+>
+
+30 
+	~<hurd/·ths.h
+>
+
+31 
+	~<sys/mmª.h
+>
+
+33 
+	~"uniÚfs.h
+"
+
+34 
+	~"ulfs.h
+"
+
+35 
+	~"node.h
+"
+
+36 
+	~"lib.h
+"
+
+37 
+	~"nÿche.h
+"
+
+38 
+	~"ÝtiÚs.h
+"
+
+43 
+”rÜ_t
+
+
+44 
+	$Ãtfs_­³nd_¬gs
+ (**
+¬gz
+, 
+size_t
+ *
+¬gz_Ën
+)
+
+46 
+”rÜ_t
+ 
+”r
+ = 0;
+
+48 
+ulfs_™”©e
+
+
+50 ià(! 
+”r
+)
+
+51 ià(
+uniÚfs_æags
+ & 
+FLAG_UNIONFS_MODE_DEBUG
+)
+
+52 
+”r
+ = 
+	`¬gz_add
+ (
+¬gz
+, 
+¬gz_Ën
+,
+
+53 
+	`OPT_LONG
+ (
+OPT_LONG_DEBUG
+));
+
+54 ià(! 
+”r
+)
+
+55 ià(
+ulfs
+->
+æags
+ & 
+FLAG_ULFS_WRITABLE
+)
+
+56 
+”r
+ = 
+	`¬gz_add
+ (
+¬gz
+, 
+¬gz_Ën
+,
+
+57 
+	`OPT_LONG
+ (
+OPT_LONG_WRITABLE
+));
+
+58 ià(! 
+”r
+)
+
+59 ià(
+ulfs
+->
+´iÜ™y
+)
+
+61 *
+buf
+ = 
+NULL
+;
+
+62 ià((
+”r
+ = 
+	`a¥rštf
+ (&
+buf
+, "%s=%s", 
+	`OPT_LONG
+ (
+OPT_LONG_PRIORITY
+),
+
+63 
+ulfs
+->
+´iÜ™y
+)) != -1)
+
+65 
+”r
+ = 
+	`¬gz_add
+ (
+¬gz
+, 
+¬gz_Ën
+, 
+buf
+);
+
+66 
+	`ä“
+ (
+buf
+);
+
+70 ià(! 
+”r
+)
+
+72 ià(
+ulfs
+->
+·th
+)
+
+73 
+”r
+ = 
+	`¬gz_add
+ (
+¬gz
+, 
+¬gz_Ën
+, 
+ulfs
+->
+·th
+);
+
+75 
+”r
+ = 
+	`¬gz_add
+ (
+¬gz
+, 
+¬gz_Ën
+,
+
+76 
+	`OPT_LONG
+ (
+OPT_LONG_UNDERLYING
+));
+
+80  
+”r
+;
+
+81 
+	}
+}
+
+83 #iâdeà
+__USE_FILE_OFFSET64
+
+
+84 

+	#OFFSET_T
+ 
+__off_t
+
+
+	)
+
+86 

+	#OFFSET_T
+ 
+__off64_t
+
+
+	)
+
+89 
+”rÜ_t
+
+
+90 
+	$_g‘_node_size
+ (
+node
+ *
+dœ
+, 
+OFFSET_T
+ *
+off
+)
+
+92 
+size_t
+ 
+size
+ = 0;
+
+93 
+”rÜ_t
+ 
+”r
+;
+
+94 
+couÁ
+ = 0;
+
+95 
+node_dœ’t_t
+ *
+dœ’t_¡¬t
+, *
+dœ’t_cu¼’t
+;
+
+96 
+node_dœ’t_t
+ *
+dœ’t_li¡
+ = 
+NULL
+;
+
+97 
+fœ¡_’Œy
+ = 2;
+
+99 
+	`bump_size
+ (cÚ¡ *
+Çme
+)
+
+101 
+size_t
+ 
+Ãw_size
+ = 
+size
+ + 
+	`DIRENT_LEN
+ (
+	`¡¾’
+ (
+Çme
+));
+
+103 
+size
+ = 
+Ãw_size
+;
+
+104 
+couÁ
+ ++;
+
+108 
+”r
+ = 
+	`node_’Œ›s_g‘
+ (
+dœ
+, &
+dœ’t_li¡
+);
+
+109 ià(
+”r
+)
+
+110  
+”r
+;
+
+112 
+dœ’t_¡¬t
+ = 
+dœ’t_li¡
+, 
+couÁ
+ = 2;
+
+113 
+dœ’t_¡¬t
+ && 
+fœ¡_’Œy
+ > 
+couÁ
+;
+
+114 
+dœ’t_¡¬t
+ = dœ’t_¡¬t->
+Ãxt
+, 
+couÁ
+++);
+
+116 
+couÁ
+ = 0;
+
+119 ià(
+fœ¡_’Œy
+ == 0)
+
+120 
+	`bump_size
+ (".");
+
+121 ià(
+fœ¡_’Œy
+ <= 1)
+
+122 
+	`bump_size
+ ("..");
+
+125 
+dœ’t_cu¼’t
+ = 
+dœ’t_¡¬t
+;
+
+126 
+dœ’t_cu¼’t
+;
+
+127 
+dœ’t_cu¼’t
+ = dœ’t_cu¼’t->
+Ãxt
+)
+
+128 ià(! 
+	`bump_size
+ (
+dœ’t_cu¼’t
+->
+dœ’t
+->
+d_Çme
+))
+
+131 
+	`ä“
+ (
+dœ’t_li¡
+);
+
+133 *
+off
+ = 
+size
+;
+
+136 
+	}
+}
+
+141 
+”rÜ_t
+
+
+142 
+	$Ãtfs_v®id©e_¡©
+ (
+node
+ *
+Å
+, 
+iou£r
+ *
+üed
+)
+
+144 
+”rÜ_t
+ 
+”r
+ = 0;
+
+146 ià(
+Å
+ !ð
+Ãtfs_roÙ_node
+)
+
+148 ià(! (
+Å
+->
+Â
+->
+æags
+ & 
+FLAG_NODE_ULFS_UPTODATE
+))
+
+149 
+”r
+ = 
+	`node_upd©e
+ (
+Å
+);
+
+150 ià(! 
+”r
+)
+
+152 
+dÚe
+ = 0;
+
+154 
+	`node_ulfs_™”©e_uÆocked
+ (
+Å
+)
+
+155 ià((! 
+dÚe
+è&& 
+	`pÜt_v®id
+ (
+node_ulfs
+->
+pÜt
+))
+
+157 
+”r
+ = 
+	`io_¡©
+ (
+node_ulfs
+->
+pÜt
+, &
+Å
+->
+Â_¡©
+);
+
+158 ià(! 
+”r
+)
+
+159 
+Å
+->
+Â_Œª¦©ed
+ =‚p->
+Â_¡©
+.
+¡_mode
+;
+
+160 
+dÚe
+ = 1;
+
+162 ià(! 
+dÚe
+)
+
+163 
+”r
+ = 
+ENOENT
+;
+
+168 
+	`_g‘_node_size
+ (
+Å
+, &Å->
+Â_¡©
+.
+¡_size
+);
+
+171  
+”r
+;
+
+172 
+	}
+}
+
+176 
+”rÜ_t
+
+
+177 
+	$Ãtfs_©‹m±_chown
+ (
+iou£r
+ *
+üed
+, 
+node
+ *
+Å
+,
+
+178 
+uid_t
+ 
+uid
+, uid_ˆ
+gid
+)
+
+180  
+EOPNOTSUPP
+;
+
+181 
+	}
+}
+
+185 
+”rÜ_t
+
+
+186 
+	$Ãtfs_©‹m±_chauthÜ
+ (
+iou£r
+ *
+üed
+, 
+node
+ *
+Å
+,
+
+187 
+uid_t
+ 
+authÜ
+)
+
+189  
+EOPNOTSUPP
+;
+
+190 
+	}
+}
+
+197 
+”rÜ_t
+
+
+198 
+	$Ãtfs_©‹m±_chmod
+ (
+iou£r
+ *
+üed
+, 
+node
+ *
+Å
+,
+
+199 
+mode_t
+ 
+mode
+)
+
+201  
+EOPNOTSUPP
+;
+
+202 
+	}
+}
+
+206 
+”rÜ_t
+
+
+207 
+	$Ãtfs_©‹m±_mksymlšk
+ (
+iou£r
+ *
+üed
+, 
+node
+ *
+Å
+,
+
+208 *
+Çme
+)
+
+210  
+EOPNOTSUPP
+;
+
+211 
+	}
+}
+
+215 
+”rÜ_t
+
+
+216 
+	$Ãtfs_©‹m±_mkdev
+ (
+iou£r
+ *
+üed
+, 
+node
+ *
+Å
+,
+
+217 
+mode_t
+ 
+ty³
+, 
+dev_t
+ 
+šdexes
+)
+
+219  
+EOPNOTSUPP
+;
+
+220 
+	}
+}
+
+224 
+”rÜ_t
+
+
+225 
+	$Ãtfs_£t_Œª¦©Ü
+ (
+iou£r
+ *
+üed
+, 
+node
+ *
+Å
+,
+
+226 *
+¬gz
+, 
+size_t
+ 
+¬gzËn
+)
+
+228  
+EOPNOTSUPP
+;
+
+229 
+	}
+}
+
+234 
+”rÜ_t
+
+
+235 
+	$Ãtfs_g‘_Œª¦©Ü
+ (
+node
+ *node, **
+¬gz
+,
+
+236 
+size_t
+ *
+¬gz_Ën
+)
+
+238  
+EOPNOTSUPP
+;
+
+239 
+	}
+}
+
+243 
+”rÜ_t
+
+
+244 
+	$Ãtfs_©‹m±_chæags
+ (
+iou£r
+ *
+üed
+, 
+node
+ *
+Å
+,
+
+245 
+æags
+)
+
+247  
+EOPNOTSUPP
+;
+
+248 
+	}
+}
+
+253 
+”rÜ_t
+
+
+254 
+	$Ãtfs_©‹m±_utimes
+ (
+iou£r
+ *
+üed
+, 
+node
+ *
+Å
+,
+
+255 
+time¥ec
+ *
+©ime
+, time¥eø*
+mtime
+)
+
+258 
+	}
+}
+
+262 
+”rÜ_t
+
+
+263 
+	$Ãtfs_©‹m±_£t_size
+ (
+iou£r
+ *
+üed
+, 
+node
+ *
+Å
+,
+
+264 
+off_t
+ 
+size
+)
+
+266  
+EOPNOTSUPP
+;
+
+267 
+	}
+}
+
+271 
+”rÜ_t
+
+
+272 
+	$Ãtfs_©‹m±_¡©fs
+ (
+iou£r
+ *
+üed
+, 
+node
+ *
+Å
+,
+
+273 
+¡©fs
+ *
+¡
+)
+
+275  
+EOPNOTSUPP
+;
+
+276 
+	}
+}
+
+281 
+”rÜ_t
+
+
+282 
+	$Ãtfs_©‹m±_sync
+ (
+iou£r
+ *
+üed
+, 
+node
+ *
+Å
+,
+
+283 
+wa™
+)
+
+285  
+EOPNOTSUPP
+;
+
+286 
+	}
+}
+
+290 
+”rÜ_t
+
+
+291 
+	$Ãtfs_©‹m±_syncfs
+ (
+iou£r
+ *
+üed
+, 
+wa™
+)
+
+294 
+	}
+}
+
+299 
+”rÜ_t
+
+
+300 
+	$Ãtfs_©‹m±_lookup
+ (
+iou£r
+ *
+u£r
+, 
+node
+ *
+dœ
+,
+
+301 *
+Çme
+, 
+node
+ **node)
+
+303  
+EOPNOTSUPP
+;
+
+304 
+	}
+}
+
+307 
+”rÜ_t
+
+
+308 
+	$Ãtfs_©‹m±_uÆšk
+ (
+iou£r
+ *
+u£r
+, 
+node
+ *
+dœ
+,
+
+309 *
+Çme
+)
+
+311 
+”rÜ_t
+ 
+”r
+ = 0;
+
+312 
+mach_pÜt_t
+ 
+p
+;
+
+313 
+¡©
+ 
+¡©buf
+;
+
+315 
+	`node_upd©e
+ (
+dœ
+);
+
+317 
+”r
+ = 
+	`node_lookup_fže
+ (
+dœ
+, 
+Çme
+, 0, &
+p
+, &
+¡©buf
+);
+
+318 ià(
+”r
+)
+
+319  
+”r
+;
+
+321 
+	`pÜt_d—Îoc
+ (
+p
+);
+
+323 
+”r
+ = 
+	`fsh–p_checkdœmod
+ (&
+dœ
+->
+Â_¡©
+, &
+¡©buf
+, 
+u£r
+);
+
+324 ià(
+”r
+)
+
+325  
+”r
+;
+
+327 
+”r
+ = 
+	`node_uÆšk_fže
+ (
+dœ
+, 
+Çme
+);
+
+329  
+”r
+;
+
+330 
+	}
+}
+
+334 
+”rÜ_t
+
+
+335 
+	$Ãtfs_©‹m±_»Çme
+ (
+iou£r
+ *
+u£r
+, 
+node
+ *
+äomdœ
+,
+
+336 *
+äomÇme
+, 
+node
+ *
+todœ
+,
+
+337 *
+tÚame
+, 
+exþ
+)
+
+339  
+EOPNOTSUPP
+;
+
+340 
+	}
+}
+
+344 
+”rÜ_t
+
+
+345 
+	$Ãtfs_©‹m±_mkdœ
+ (
+iou£r
+ *
+u£r
+, 
+node
+ *
+dœ
+,
+
+346 *
+Çme
+, 
+mode_t
+ 
+mode
+)
+
+348 
+”rÜ_t
+ 
+”r
+ = 0;
+
+349 
+mach_pÜt_t
+ 
+p
+;
+
+350 
+¡©
+ 
+¡©buf
+;
+
+352 
+	`node_upd©e
+ (
+dœ
+);
+
+354 
+”r
+ = 
+	`fsh–p_checkdœmod
+ (&
+dœ
+->
+Â_¡©
+, 0, 
+u£r
+);
+
+355 ià(
+”r
+)
+
+356 
+ex™
+;
+
+359 ià((!
+u£r
+->
+uids
+->
+ids
+) || (!user->uids->ids))
+
+361 
+”r
+ = 
+EACCES
+;
+
+362 
+ex™
+;
+
+365 
+”r
+ = 
+	`node_dœ_ü—‹
+ (
+dœ
+, 
+Çme
+, 
+mode
+);
+
+366 ià(
+”r
+)
+
+367 
+ex™
+;
+
+369 
+”r
+ = 
+	`node_lookup_fže
+ (
+dœ
+, 
+Çme
+, 0, &
+p
+, &
+¡©buf
+);
+
+370 ià(
+”r
+)
+
+372 
+	`node_dœ_»move
+ (
+dœ
+, 
+Çme
+);
+
+373 
+ex™
+;
+
+376 
+”r
+ = 
+	`fže_chown
+ (
+p
+, 
+u£r
+->
+uids
+->
+ids
+[0], u£r->
+gids
+->ids[0]);
+
+377 ià(
+”r
+)
+
+379 
+	`pÜt_d—Îoc
+ (
+p
+);
+
+380 
+	`node_dœ_»move
+ (
+dœ
+, 
+Çme
+);
+
+381 
+ex™
+;
+
+384 
+	`pÜt_d—Îoc
+ (
+p
+);
+
+386 
+ex™
+:
+
+388  
+”r
+;
+
+389 
+	}
+}
+
+393 
+”rÜ_t
+
+
+394 
+	$Ãtfs_©‹m±_rmdœ
+ (
+iou£r
+ *
+u£r
+,
+
+395 
+node
+ *
+dœ
+, *
+Çme
+)
+
+397 
+”rÜ_t
+ 
+”r
+ = 0;
+
+398 
+mach_pÜt_t
+ 
+p
+;
+
+399 
+¡©
+ 
+¡©buf
+;
+
+401 
+	`node_upd©e
+ (
+dœ
+);
+
+403 
+”r
+ = 
+	`node_lookup_fže
+ (
+dœ
+, 
+Çme
+, 0, &
+p
+, &
+¡©buf
+);
+
+404 ià(
+”r
+)
+
+405  
+”r
+;
+
+407 
+	`pÜt_d—Îoc
+ (
+p
+);
+
+409 
+”r
+ = 
+	`fsh–p_checkdœmod
+ (&
+dœ
+->
+Â_¡©
+, &
+¡©buf
+, 
+u£r
+);
+
+410 ià(
+”r
+)
+
+411  
+”r
+;
+
+413 
+”r
+ = 
+	`node_dœ_»move
+ (
+dœ
+, 
+Çme
+);
+
+415  
+”r
+;
+
+416 
+	}
+}
+
+421 
+”rÜ_t
+
+
+422 
+	$Ãtfs_©‹m±_lšk
+ (
+iou£r
+ *
+u£r
+, 
+node
+ *
+dœ
+,
+
+423 
+node
+ *
+fže
+, *
+Çme
+, 
+exþ
+)
+
+425  
+EOPNOTSUPP
+;
+
+426 
+	}
+}
+
+431 
+”rÜ_t
+
+
+432 
+	$Ãtfs_©‹m±_mkfže
+ (
+iou£r
+ *
+u£r
+, 
+node
+ *
+dœ
+,
+
+433 
+mode_t
+ 
+mode
+, 
+node
+ **
+Å
+)
+
+435 
+	`mu‹x_uÆock
+ (&
+dœ
+->
+lock
+);
+
+436  
+EOPNOTSUPP
+;
+
+437 
+	}
+}
+
+443 
+”rÜ_t
+
+
+444 
+	$Ãtfs_©‹m±_ü—‹_fže
+ (
+iou£r
+ *
+u£r
+, 
+node
+ *
+dœ
+,
+
+445 *
+Çme
+, 
+mode_t
+ 
+mode
+, 
+node
+ **
+Å
+)
+
+447 
+	`mu‹x_uÆock
+ (&
+dœ
+->
+lock
+);
+
+448  
+EOPNOTSUPP
+;
+
+449 
+	}
+}
+
+453 
+”rÜ_t
+
+
+454 
+	$Ãtfs_©‹m±_ü—‹_fže_»duûd
+ (
+iou£r
+ *
+u£r
+, 
+node
+ *
+dœ
+,
+
+455 *
+Çme
+, 
+mode_t
+ 
+mode
+, 
+æags
+)
+
+457 
+mach_pÜt_t
+ 
+p
+;
+
+458 
+”rÜ_t
+ 
+”r
+;
+
+459 
+¡©
+ 
+¡©buf
+;
+
+461 
+	`node_upd©e
+ (
+dœ
+);
+
+463 
+”r
+ = 
+	`fsh–p_checkdœmod
+ (&
+dœ
+->
+Â_¡©
+, 0, 
+u£r
+);
+
+464 ià(
+”r
+)
+
+465 
+ex™
+;
+
+468 ià((!
+u£r
+->
+uids
+->
+ids
+) || (!user->uids->ids))
+
+470 
+”r
+ = 
+EACCES
+;
+
+471 
+ex™
+;
+
+474 
+	`mu‹x_uÆock
+ (&
+dœ
+->
+lock
+);
+
+475 
+”r
+ = 
+	`node_lookup_fže
+ (
+dœ
+, 
+Çme
+, 
+æags
+ | 
+O_CREAT
+,
+
+476 &
+p
+, &
+¡©buf
+);
+
+477 
+	`mu‹x_lock
+ (&
+dœ
+->
+lock
+);
+
+479 ià(
+”r
+)
+
+480 
+ex™
+;
+
+482 
+”r
+ = 
+	`fže_chmod
+ (
+p
+, 
+mode
+);
+
+483 ià(
+”r
+)
+
+485 
+	`pÜt_d—Îoc
+ (
+p
+);
+
+486 
+	`node_uÆšk_fže
+ (
+dœ
+, 
+Çme
+);
+
+487 
+ex™
+;
+
+490 
+”r
+ = 
+	`fže_chown
+ (
+p
+, 
+u£r
+->
+uids
+->
+ids
+[0], u£r->
+gids
+->ids[0]);
+
+491 ià(
+”r
+)
+
+493 
+	`pÜt_d—Îoc
+ (
+p
+);
+
+494 
+	`node_uÆšk_fže
+ (
+dœ
+, 
+Çme
+);
+
+495 
+ex™
+;
+
+498 
+”r
+ = 
+	`io_¡©
+ (
+p
+, &
+¡©buf
+);
+
+501 ià(! 
+”r
+ && (
+æags
+ & 
+O_READ
+))
+
+502 
+”r
+ = 
+	`fsh–p_acûss
+ (&
+¡©buf
+, 
+S_IREAD
+, 
+u£r
+);
+
+503 ià(! 
+”r
+ && (
+æags
+ & 
+O_WRITE
+))
+
+504 
+”r
+ = 
+	`fsh–p_acûss
+ (&
+¡©buf
+, 
+S_IWRITE
+, 
+u£r
+);
+
+505 ià(! 
+”r
+ && (
+æags
+ & 
+O_EXEC
+))
+
+506 
+”r
+ = 
+	`fsh–p_acûss
+ (&
+¡©buf
+, 
+S_IEXEC
+, 
+u£r
+);
+
+508 ià(
+”r
+)
+
+510 
+	`pÜt_d—Îoc
+ (
+p
+);
+
+511 
+	`node_uÆšk_fže
+ (
+dœ
+, 
+Çme
+);
+
+512 
+ex™
+;
+
+515 
+	`pÜt_d—Îoc
+ (
+p
+);
+
+517 
+ex™
+:
+
+518 
+	`mu‹x_uÆock
+ (&
+dœ
+->
+lock
+);
+
+519  
+”r
+;
+
+520 
+	}
+}
+
+524 
+”rÜ_t
+
+
+525 
+	$Ãtfs_©‹m±_»adlšk
+ (
+iou£r
+ *
+u£r
+, 
+node
+ *
+Å
+,
+
+526 *
+buf
+)
+
+528  
+EOPNOTSUPP
+;
+
+529 
+	}
+}
+
+532 
+”rÜ_t
+
+
+533 
+	$Ãtfs_check_Ý’_³rmissiÚs
+ (
+iou£r
+ *
+u£r
+, 
+node
+ *
+Å
+,
+
+534 
+æags
+, 
+Ãwnode
+)
+
+536 
+”rÜ_t
+ 
+”r
+ = 0;
+
+538 ià(! 
+”r
+ && (
+æags
+ & 
+O_READ
+))
+
+539 
+”r
+ = 
+	`fsh–p_acûss
+ (&
+Å
+->
+Â_¡©
+, 
+S_IREAD
+, 
+u£r
+);
+
+540 ià(! 
+”r
+ && (
+æags
+ & 
+O_WRITE
+))
+
+541 
+”r
+ = 
+	`fsh–p_acûss
+ (&
+Å
+->
+Â_¡©
+, 
+S_IWRITE
+, 
+u£r
+);
+
+542 ià(! 
+”r
+ && (
+æags
+ & 
+O_EXEC
+))
+
+543 
+”r
+ = 
+	`fsh–p_acûss
+ (&
+Å
+->
+Â_¡©
+, 
+S_IEXEC
+, 
+u£r
+);
+
+545  
+”r
+;
+
+546 
+	}
+}
+
+551 
+”rÜ_t
+
+
+552 
+	$Ãtfs_©‹m±_»ad
+ (
+iou£r
+ *
+üed
+, 
+node
+ *
+Å
+,
+
+553 
+off_t
+ 
+off£t
+, 
+size_t
+ *
+Ën
+, *
+d©a
+)
+
+555 *
+Ën
+ = 0;
+
+557 
+	}
+}
+
+562 
+”rÜ_t
+
+
+563 
+	$Ãtfs_©‹m±_wr™e
+ (
+iou£r
+ *
+üed
+, 
+node
+ *
+Å
+,
+
+564 
+off_t
+ 
+off£t
+, 
+size_t
+ *
+Ën
+, *
+d©a
+)
+
+567  
+EISDIR
+;
+
+568 
+	}
+}
+
+572 
+”rÜ_t
+
+
+573 
+	$Ãtfs_»pÜt_acûss
+ (
+iou£r
+ *
+üed
+, 
+node
+ *
+Å
+,
+
+574 *
+ty³s
+)
+
+576 *
+ty³s
+ = 0;
+
+577 ià(
+	`fsh–p_acûss
+ (&
+Å
+->
+Â_¡©
+, 
+S_IREAD
+, 
+üed
+) == 0)
+
+578 *
+ty³s
+ |ð
+O_READ
+;
+
+579 ià(
+	`fsh–p_acûss
+ (&
+Å
+->
+Â_¡©
+, 
+S_IWRITE
+, 
+üed
+) == 0)
+
+580 *
+ty³s
+ |ð
+O_WRITE
+;
+
+581 ià(
+	`fsh–p_acûss
+ (&
+Å
+->
+Â_¡©
+, 
+S_IEXEC
+, 
+üed
+) == 0)
+
+582 *
+ty³s
+ |ð
+O_EXEC
+;
+
+584 
+	}
+}
+
+587 
+iou£r
+ *
+
+588 
+	$Ãtfs_make_u£r
+ (
+uid_t
+ *
+uids
+, 
+nuids
+, uid_ˆ*
+gids
+, 
+ngids
+)
+
+590  
+NULL
+;
+
+591 
+	}
+}
+
+595 
+	$Ãtfs_node_nÜefs
+ (
+node
+ *
+Å
+)
+
+597 
+	`node_de¡roy
+ (
+Å
+);
+
+598 
+	}
+}
+
+600 
+”rÜ_t
+
+
+601 
+	$Ãtfs_©‹m±_lookup_im´oved
+ (
+iou£r
+ *
+u£r
+, 
+node
+ *
+dœ
+,
+
+602 *
+Çme
+, 
+node
+ **
+Å
+,
+
+603 
+æags
+, 
+Ï¡comp
+,
+
+604 
+mach_pÜt_t
+ *
+pÜt
+,
+
+605 
+mach_msg_ty³_Çme_t
+ *
+pÜt_ty³
+)
+
+607 
+mach_pÜt_t
+ 
+p
+;
+
+608 
+”rÜ_t
+ 
+”r
+;
+
+610 
+	`mu‹x_lock
+ (&
+dœ
+->
+Â
+->
+Êode
+->
+lock
+);
+
+612 
+”r
+ = 
+	`fsh–p_acûss
+ (&
+dœ
+->
+Â_¡©
+, 
+S_IEXEC
+, 
+u£r
+);
+
+613 ià(
+”r
+)
+
+614 
+ex™
+;
+
+617 ià(! *
+Çme
+ || ! 
+	`¡rcmp
+ (name, "."))
+
+621 *
+Å
+ = 
+dœ
+;
+
+622 
+	`Ãtfs_Äef
+ (*
+Å
+);
+
+625 ià(! 
+	`¡rcmp
+ (
+Çme
+, ".."))
+
+629 
+Êode_t
+ *
+Êode
+ = 
+dœ
+->
+Â
+->lnode;
+
+630 
+node_t
+ *
+node
+;
+
+632 
+”r
+ = 
+	`nÿche_node_lookup
+ (
+Êode
+->
+dœ
+, &
+node
+);
+
+633 ià(
+”r
+)
+
+634 
+ex™
+;
+
+636 *
+Å
+ = 
+node
+;
+
+642 
+Êode_t
+ *
+dœ_Êode
+ = 
+dœ
+->
+Â
+->
+Êode
+;
+
+643 
+¡©
+ 
+¡©buf
+;
+
+644 
+Êode_t
+ *
+Êode
+ = 
+NULL
+;
+
+649 
+”r
+ = 
+	`node_upd©e
+ (
+dœ
+);
+
+652 
+	`mu‹x_uÆock
+ (&
+dœ_Êode
+->
+lock
+);
+
+653 
+	`mu‹x_uÆock
+ (&
+dœ
+->
+lock
+);
+
+655 
+”r
+ = 
+	`node_lookup_fže
+ (
+dœ
+, 
+Çme
+, 
+æags
+ & ~(
+O_NOLINK
+|
+O_CREAT
+),
+
+656 &
+p
+, &
+¡©buf
+);
+
+658 
+	`mu‹x_lock
+ (&
+dœ
+->
+lock
+);
+
+659 
+	`mu‹x_lock
+ (&
+dœ_Êode
+->
+lock
+);
+
+662 ià(
+”r
+)
+
+663 
+ex™
+;
+
+665 ià(
+	`S_ISDIR
+ (
+¡©buf
+.
+¡_mode
+))
+
+667 
+node_t
+ *
+node
+;
+
+670 
+	`pÜt_d—Îoc
+ (
+p
+);
+
+675 
+”r
+ = 
+	`Êode_g‘
+ (
+dœ_Êode
+, 
+Çme
+, &
+Êode
+);
+
+676 ià(
+”r
+ =ð
+ENOENT
+)
+
+679 
+”r
+ = 
+	`Êode_ü—‹
+ (
+Çme
+, &
+Êode
+);
+
+680 ià(
+”r
+)
+
+681 
+ex™
+;
+
+683 
+	`Êode_š¡®l
+ (
+dœ_Êode
+, 
+Êode
+);
+
+687 
+”r
+ = 
+	`nÿche_node_lookup
+ (
+Êode
+, &
+node
+);
+
+690 
+	`Êode_»f_»move
+ (
+Êode
+);
+
+692 ià(
+”r
+)
+
+693 
+ex™
+;
+
+696 *
+Å
+ = 
+node
+;
+
+702 
+mach_pÜt_t
+ 
+p_»¡riùed
+;
+
+704 ià(! 
+Ï¡comp
+)
+
+707 
+	`pÜt_d—Îoc
+ (
+p
+);
+
+708 
+”r
+ = 
+ENOTDIR
+;
+
+709 
+ex™
+;
+
+713 ià(! 
+”r
+ && (
+æags
+ & 
+O_READ
+))
+
+714 
+”r
+ = 
+	`fsh–p_acûss
+ (&
+¡©buf
+, 
+S_IREAD
+, 
+u£r
+);
+
+715 ià(! 
+”r
+ && (
+æags
+ & 
+O_WRITE
+))
+
+716 
+”r
+ = 
+	`fsh–p_acûss
+ (&
+¡©buf
+, 
+S_IWRITE
+, 
+u£r
+);
+
+717 ià(! 
+”r
+ && (
+æags
+ & 
+O_EXEC
+))
+
+718 
+”r
+ = 
+	`fsh–p_acûss
+ (&
+¡©buf
+, 
+S_IEXEC
+, 
+u£r
+);
+
+720 ià(
+”r
+)
+
+722 
+	`pÜt_d—Îoc
+ (
+p
+);
+
+723 
+ex™
+;
+
+728 
+”r
+ = 
+	`io_»¡riù_auth
+ (
+p
+, &
+p_»¡riùed
+,
+
+729 
+u£r
+->
+uids
+->
+ids
+, u£r->uids->
+num
+,
+
+730 
+u£r
+->
+gids
+->
+ids
+, u£r->gids->
+num
+);
+
+731 
+	`pÜt_d—Îoc
+ (
+p
+);
+
+733 ià(
+”r
+)
+
+734 
+ex™
+;
+
+737 *
+pÜt
+ = 
+p_»¡riùed
+;
+
+738 *
+pÜt_ty³
+ = 
+MACH_MSG_TYPE_MOVE_SEND
+;
+
+742 
+ex™
+:
+
+744 ià(
+”r
+)
+
+745 *
+Å
+ = 
+NULL
+;
+
+746 ià(*
+Å
+)
+
+748 
+	`mu‹x_uÆock
+ (&(*
+Å
+)->
+lock
+);
+
+749 
+	`nÿche_node_add
+ (*
+Å
+);
+
+752 
+	`mu‹x_uÆock
+ (&
+dœ
+->
+Â
+->
+Êode
+->
+lock
+);
+
+753 
+	`mu‹x_uÆock
+ (&
+dœ
+->
+lock
+);
+
+754  
+”r
+;
+
+755 
+	}
+}
+
+762 

+	#OPENONLY_STATE_MODES
+ (
+O_CREAT
+|
+O_EXCL
+|
+O_NOLINK
+|
+O_NOTRANS
+|
+O_NONBLOCK
+)
+
+	)
+
+764 
+fsh–p_ãtch_roÙ_ÿÎback1_t
+ 
+	g_Ãtfs_Œª¦©Ü_ÿÎback1
+;
+
+765 
+fsh–p_ãtch_roÙ_ÿÎback2_t
+ 
+	g_Ãtfs_Œª¦©Ü_ÿÎback2
+;
+
+767 
+”rÜ_t
+
+
+768 
+	$Ãtfs_S_dœ_lookup
+ (
+´Ùid
+ *
+dœu£r
+,
+
+769 *
+fž’ame
+,
+
+770 
+æags
+,
+
+771 
+mode_t
+ 
+mode
+,
+
+772 
+»Œy_ty³
+ *
+do_»Œy
+,
+
+773 *
+»Œy_Çme
+,
+
+774 
+mach_pÜt_t
+ *
+»Œy_pÜt
+,
+
+775 
+mach_msg_ty³_Çme_t
+ *
+»Œy_pÜt_ty³
+)
+
+777 
+ü—‹
+;
+
+778 
+exþ
+;
+
+779 
+mu¡bedœ
+ = 0;
+
+780 
+Ï¡comp
+ = 0;
+
+781 
+Ãwnode
+ = 0;
+
+782 
+nsymlšks
+ = 0;
+
+783 
+node
+ *
+dÅ
+, *
+Å
+;
+
+784 *
+ÃxŠame
+;
+
+785 
+”rÜ_t
+ 
+”rÜ
+ = 0;
+
+786 
+´Ùid
+ *
+Ãwpi
+;
+
+787 
+iou£r
+ *
+u£r
+;
+
+789 ià(!
+dœu£r
+)
+
+790  
+EOPNOTSUPP
+;
+
+792 
+ü—‹
+ = (
+æags
+ & 
+O_CREAT
+);
+
+793 
+exþ
+ = (
+æags
+ & 
+O_EXCL
+);
+
+796 *
+fž’ame
+ == '/')
+
+797 
+fž’ame
+++;
+
+799 *
+»Œy_pÜt_ty³
+ = 
+MACH_MSG_TYPE_MAKE_SEND
+;
+
+800 *
+do_»Œy
+ = 
+FS_RETRY_NORMAL
+;
+
+801 *
+»Œy_Çme
+ = '\0';
+
+803 ià(*
+fž’ame
+ == '\0')
+
+806 
+dÅ
+ = 0;
+
+807 
+Å
+ = 
+dœu£r
+->
+po
+->np;
+
+808 
+	`mu‹x_lock
+ (&
+Å
+->
+lock
+);
+
+809 
+	`Ãtfs_Äef
+ (
+Å
+);
+
+810 
+gÙ™
+;
+
+813 
+dÅ
+ = 
+dœu£r
+->
+po
+->
+Å
+;
+
+815 
+	`mu‹x_lock
+ (&
+dÅ
+->
+lock
+);
+
+817 
+	`Ãtfs_Äef
+ (
+dÅ
+);
+
+821 
+	`as£¹
+ (!
+Ï¡comp
+);
+
+824 
+ÃxŠame
+ = 
+	`šdex
+ (
+fž’ame
+, '/');
+
+826 ià(
+ÃxŠame
+)
+
+828 *
+ÃxŠame
+++ = '\0';
+
+829 *
+ÃxŠame
+ == '/')
+
+830 
+ÃxŠame
+++;
+
+831 ià(*
+ÃxŠame
+ == '\0')
+
+834 
+ÃxŠame
+ = 0;
+
+835 
+Ï¡comp
+ = 1;
+
+836 
+mu¡bedœ
+ = 1;
+
+837 
+ü—‹
+ = 0;
+
+840 
+Ï¡comp
+ = 0;
+
+843 
+Ï¡comp
+ = 1;
+
+845 
+Å
+ = 0;
+
+847 
+»Œy_lookup
+:
+
+849 ià((
+dÅ
+ =ð
+Ãtfs_roÙ_node
+ || dÅ =ð
+dœu£r
+->
+po
+->
+shadow_roÙ
+)
+
+850 && 
+fž’ame
+[0] == '.' && filename[1] == '.' && filename[2] == '\0')
+
+851 ià(
+dÅ
+ =ð
+dœu£r
+->
+po
+->
+shadow_roÙ
+)
+
+854 *
+do_»Œy
+ = 
+FS_RETRY_REAUTH
+;
+
+855 *
+»Œy_pÜt
+ = 
+dœu£r
+->
+po
+->
+shadow_roÙ_·»Á
+;
+
+856 *
+»Œy_pÜt_ty³
+ = 
+MACH_MSG_TYPE_COPY_SEND
+;
+
+857 ià(! 
+Ï¡comp
+)
+
+858 
+	`¡rýy
+ (
+»Œy_Çme
+, 
+ÃxŠame
+);
+
+859 
+”rÜ
+ = 0;
+
+860 
+	`mu‹x_uÆock
+ (&
+dÅ
+->
+lock
+);
+
+861 
+out
+;
+
+863 ià(
+dœu£r
+->
+po
+->
+roÙ_·»Á
+ !ð
+MACH_PORT_NULL
+)
+
+868 *
+do_»Œy
+ = 
+FS_RETRY_REAUTH
+;
+
+869 *
+»Œy_pÜt
+ = 
+dœu£r
+->
+po
+->
+roÙ_·»Á
+;
+
+870 *
+»Œy_pÜt_ty³
+ = 
+MACH_MSG_TYPE_COPY_SEND
+;
+
+871 ià(!
+Ï¡comp
+)
+
+872 
+	`¡rýy
+ (
+»Œy_Çme
+, 
+ÃxŠame
+);
+
+873 
+”rÜ
+ = 0;
+
+874 
+	`mu‹x_uÆock
+ (&
+dÅ
+->
+lock
+);
+
+875 
+out
+;
+
+880 
+”rÜ
+ = 0;
+
+881 
+Å
+ = 
+dÅ
+;
+
+882 
+	`Ãtfs_Äef
+ (
+Å
+);
+
+886 
+”rÜ
+ = 
+	`Ãtfs_©‹m±_lookup_im´oved
+ (
+dœu£r
+->
+u£r
+, 
+dÅ
+,
+
+887 
+fž’ame
+, &
+Å
+,
+
+888 
+æags
+, 
+Ï¡comp
+,
+
+889 
+»Œy_pÜt
+, 
+»Œy_pÜt_ty³
+);
+
+894 ià(
+Ï¡comp
+ && 
+ü—‹
+ && 
+exþ
+ && !
+”rÜ
+ && 
+Å
+)
+
+895 
+”rÜ
+ = 
+EEXIST
+;
+
+898 ià(
+Ï¡comp
+ && 
+ü—‹
+ && 
+”rÜ
+ =ð
+ENOENT
+)
+
+900 
+mode
+ &ð~(
+S_IFMT
+ | 
+S_ISPARE
+ | 
+S_ISVTX
+);
+
+901 
+mode
+ |ð
+S_IFREG
+;
+
+902 
+	`mu‹x_lock
+ (&
+dÅ
+->
+lock
+);
+
+904 
+”rÜ
+ = 
+	`Ãtfs_©‹m±_ü—‹_fže_»duûd
+ (
+dœu£r
+->
+u£r
+, 
+dÅ
+,
+
+905 
+fž’ame
+, 
+mode
+, 
+æags
+);
+
+912 ià((!
+”rÜ
+è|| (”rÜ =ð
+EEXIST
+ && !
+exþ
+))
+
+914 
+	`mu‹x_lock
+ (&
+dÅ
+->
+lock
+);
+
+915 
+»Œy_lookup
+;
+
+918 
+Ãwnode
+ = 1;
+
+922 ià(
+”rÜ
+)
+
+923 
+out
+;
+
+925 ià(
+Å
+)
+
+927 
+	`mu‹x_lock
+ (&
+Å
+->
+lock
+);
+
+928 
+”rÜ
+ = 
+	`Ãtfs_v®id©e_¡©
+ (
+Å
+, 
+dœu£r
+->
+u£r
+);
+
+929 
+	`mu‹x_uÆock
+ (&
+Å
+->
+lock
+);
+
+930 ià(
+”rÜ
+)
+
+931 
+out
+;
+
+934 ià(
+Å
+
+
+935 && 
+	`S_ISLNK
+ (
+Å
+->
+Â_Œª¦©ed
+)
+
+936 && (!
+Ï¡comp
+
+
+937 || 
+mu¡bedœ
+
+
+938 || !(
+æags
+ & (
+O_NOLINK
+|
+O_NOTRANS
+))))
+
+940 
+size_t
+ 
+ÃxŠam–’
+, 
+ÃwÇm–’
+, 
+lškËn
+;
+
+941 *
+lškbuf
+;
+
+944 ià(
+nsymlšks
+++ > 
+Ãtfs_maxsymlšks
+)
+
+946 
+”rÜ
+ = 
+ELOOP
+;
+
+947 
+out
+;
+
+950 
+lškËn
+ = 
+Å
+->
+Â_¡©
+.
+¡_size
+;
+
+952 
+ÃxŠam–’
+ = 
+ÃxŠame
+ ? 
+	`¡¾’
+ (nextname) + 1 : 0;
+
+953 
+ÃwÇm–’
+ = 
+ÃxŠam–’
+ + 
+lškËn
+ + 1;
+
+954 
+lškbuf
+ = 
+	`®loÿ
+ (
+ÃwÇm–’
+);
+
+956 
+”rÜ
+ = 
+	`Ãtfs_©‹m±_»adlšk
+ (
+dœu£r
+->
+u£r
+, 
+Å
+, 
+lškbuf
+);
+
+957 ià(
+”rÜ
+)
+
+958 
+out
+;
+
+960 ià(
+ÃxŠame
+)
+
+962 
+lškbuf
+[
+lškËn
+] = '/';
+
+963 
+	`memýy
+ (
+lškbuf
+ + 
+lškËn
+ + 1, 
+ÃxŠame
+,
+
+964 
+ÃxŠam–’
+ - 1);
+
+966 
+lškbuf
+[
+ÃxŠam–’
+ + 
+lškËn
+] = '\0';
+
+968 ià(
+lškbuf
+[0] == '/')
+
+971 *
+do_»Œy
+ = 
+FS_RETRY_MAGICAL
+;
+
+972 *
+»Œy_pÜt
+ = 
+MACH_PORT_NULL
+;
+
+973 
+	`¡rýy
+ (
+»Œy_Çme
+, 
+lškbuf
+);
+
+974 
+out
+;
+
+977 
+fž’ame
+ = 
+lškbuf
+;
+
+978 ià(
+Ï¡comp
+)
+
+980 
+Ï¡comp
+ = 0;
+
+984 
+ü—‹
+ = 0;
+
+986 
+	`Ãtfs_Åut
+ (
+Å
+);
+
+987 
+	`mu‹x_lock
+ (&
+dÅ
+->
+lock
+);
+
+988 
+Å
+ = 0;
+
+993 
+fž’ame
+ = 
+ÃxŠame
+;
+
+994 
+	`Ãtfs_Ä–e
+ (
+dÅ
+);
+
+996 ià(
+Ï¡comp
+)
+
+997 
+dÅ
+ = 0;
+
+1000 
+dÅ
+ = 
+Å
+;
+
+1001 
+Å
+ = 0;
+
+1005 
+fž’ame
+ && *filename);
+
+1008 
+gÙ™
+:
+
+1010 ià(
+mu¡bedœ
+ && ! 
+Å
+)
+
+1012 
+”rÜ
+ = 
+ENOTDIR
+;
+
+1013 
+out
+;
+
+1016 ià(
+Å
+)
+
+1017 
+”rÜ
+ = 
+	`Ãtfs_check_Ý’_³rmissiÚs
+ (
+dœu£r
+->
+u£r
+, 
+Å
+,
+
+1018 
+æags
+, 
+Ãwnode
+);
+
+1020 ià(
+”rÜ
+)
+
+1021 
+out
+;
+
+1023 
+æags
+ &ð~
+OPENONLY_STATE_MODES
+;
+
+1025 ià(
+Å
+)
+
+1027 
+”rÜ
+ = 
+	`ioh–p_dup_iou£r
+ (&
+u£r
+, 
+dœu£r
+->user);
+
+1028 ià(
+”rÜ
+)
+
+1029 
+out
+;
+
+1031 
+Ãwpi
+ = 
+	`Ãtfs_make_´Ùid
+ (
+	`Ãtfs_make_³rÝ’
+ (
+Å
+, 
+æags
+, 
+dœu£r
+->
+po
+),
+
+1032 
+u£r
+);
+
+1033 ià(! 
+Ãwpi
+)
+
+1035 
+	`ioh–p_ä“_iou£r
+ (
+u£r
+);
+
+1036 
+”rÜ
+ = 
+Ӽo
+;
+
+1037 
+out
+;
+
+1040 *
+»Œy_pÜt
+ = 
+	`pÜts_g‘_right
+ (
+Ãwpi
+);
+
+1041 
+	`pÜts_pÜt_d”ef
+ (
+Ãwpi
+);
+
+1044 
+out
+:
+
+1045 ià(
+Å
+)
+
+1046 
+	`Ãtfs_Åut
+ (
+Å
+);
+
+1047 ià(
+dÅ
+)
+
+1048 
+	`Ãtfs_Ä–e
+ (
+dÅ
+);
+
+1049  
+”rÜ
+;
+
+1050 
+	}
+}
+
+1057 
+”rÜ_t
+
+
+1058 
+	$Ãtfs_g‘_dœ’ts
+ (
+iou£r
+ *
+üed
+, 
+node
+ *
+dœ
+,
+
+1059 
+fœ¡_’Œy
+, 
+num_’Œ›s
+, **
+d©a
+,
+
+1060 
+mach_msg_ty³_numb”_t
+ *
+d©a_Ën
+,
+
+1061 
+vm_size_t
+ 
+max_d©a_Ën
+, *
+d©a_’Œ›s
+)
+
+1063 
+node_dœ’t_t
+ *
+dœ’t_¡¬t
+, *
+dœ’t_cu¼’t
+;
+
+1064 
+node_dœ’t_t
+ *
+dœ’t_li¡
+ = 
+NULL
+;
+
+1065 
+size_t
+ 
+size
+ = 0;
+
+1066 
+couÁ
+ = 0;
+
+1067 *
+d©a_p
+;
+
+1068 
+”rÜ_t
+ 
+”r
+;
+
+1070 
+	`bump_size
+ (cÚ¡ *
+Çme
+)
+
+1072 ià(
+num_’Œ›s
+ =ð-1 || 
+couÁ
+ <‚um_entries)
+
+1074 
+size_t
+ 
+Ãw_size
+ = 
+size
+ + 
+	`DIRENT_LEN
+ (
+	`¡¾’
+ (
+Çme
+));
+
+1076 ià(
+max_d©a_Ën
+ > 0 && 
+Ãw_size
+ > max_data_len)
+
+1078 
+size
+ = 
+Ãw_size
+;
+
+1079 
+couÁ
+++;
+
+1086 
+	`add_dœ’t
+ (cÚ¡ *
+Çme
+, 
+šo_t
+ 
+fž’o
+, 
+ty³
+)
+
+1088 ià(
+num_’Œ›s
+ =ð-1 || 
+couÁ
+ <‚um_entries)
+
+1090 
+dœ’t
+ 
+hdr
+;
+
+1091 
+size_t
+ 
+Çme_Ën
+ = 
+	`¡¾’
+ (
+Çme
+);
+
+1092 
+size_t
+ 
+sz
+ = 
+	`DIRENT_LEN
+ (
+Çme_Ën
+);
+
+1094 ià(
+sz
+ > 
+size
+)
+
+1097 
+size
+ -ð
+sz
+;
+
+1099 
+hdr
+.
+d_fž’o
+ = 
+fž’o
+;
+
+1100 
+hdr
+.
+d_»þ’
+ = 
+sz
+;
+
+1101 
+hdr
+.
+d_ty³
+ = 
+ty³
+;
+
+1102 
+hdr
+.
+d_ÇmËn
+ = 
+Çme_Ën
+;
+
+1104 
+	`memýy
+ (
+d©a_p
+, &
+hdr
+, 
+DIRENT_NAME_OFFS
+);
+
+1105 
+	`¡rýy
+ (
+d©a_p
+ + 
+DIRENT_NAME_OFFS
+, 
+Çme
+);
+
+1106 
+d©a_p
+ +ð
+sz
+;
+
+1107 
+couÁ
+++;
+
+1115 
+”r
+ = 
+	`node_’Œ›s_g‘
+ (
+dœ
+, &
+dœ’t_li¡
+);
+
+1117 ià(! 
+”r
+)
+
+1119 
+dœ’t_¡¬t
+ = 
+dœ’t_li¡
+, 
+couÁ
+ = 2;
+
+1120 
+dœ’t_¡¬t
+ && 
+fœ¡_’Œy
+ > 
+couÁ
+;
+
+1121 
+dœ’t_¡¬t
+ = dœ’t_¡¬t->
+Ãxt
+, 
+couÁ
+++);
+
+1123 
+couÁ
+ = 0;
+
+1126 ià(
+fœ¡_’Œy
+ == 0)
+
+1127 
+	`bump_size
+ (".");
+
+1128 ià(
+fœ¡_’Œy
+ <= 1)
+
+1129 
+	`bump_size
+ ("..");
+
+1132 
+dœ’t_cu¼’t
+ = 
+dœ’t_¡¬t
+;
+
+1133 
+dœ’t_cu¼’t
+;
+
+1134 
+dœ’t_cu¼’t
+ = dœ’t_cu¼’t->
+Ãxt
+)
+
+1135 ià(! 
+	`bump_size
+ (
+dœ’t_cu¼’t
+->
+dœ’t
+->
+d_Çme
+))
+
+1138 *
+d©a
+ = 
+	`mm­
+ (0, 
+size
+, 
+PROT_READ
+|
+PROT_WRITE
+, 
+MAP_ANON
+, 0, 0);
+
+1139 
+”r
+ = ((*è*
+d©a
+ =ð(*è-1è? 
+Ӽo
+ : 0;
+
+1142 ià(! 
+”r
+)
+
+1144 
+d©a_p
+ = *
+d©a
+;
+
+1145 *
+d©a_Ën
+ = 
+size
+;
+
+1146 *
+d©a_’Œ›s
+ = 
+couÁ
+;
+
+1147 
+couÁ
+ = 0;
+
+1150 ià(
+fœ¡_’Œy
+ == 0)
+
+1151 
+	`add_dœ’t
+ (".", 2, 
+DT_DIR
+);
+
+1152 ià(
+fœ¡_’Œy
+ <= 1)
+
+1153 
+	`add_dœ’t
+ ("..", 2, 
+DT_DIR
+);
+
+1155 
+dœ’t_cu¼’t
+ = 
+dœ’t_¡¬t
+;
+
+1156 
+dœ’t_cu¼’t
+;
+
+1157 
+dœ’t_cu¼’t
+ = dœ’t_cu¼’t->
+Ãxt
+)
+
+1158 ià(! 
+	`add_dœ’t
+ (
+dœ’t_cu¼’t
+->
+dœ’t
+->
+d_Çme
+,
+
+1160 
+dœ’t_cu¼’t
+->
+dœ’t
+->
+d_ty³
+))
+
+1164 ià(
+dœ’t_li¡
+)
+
+1165 
+	`node_’Œ›s_ä“
+ (
+dœ’t_li¡
+);
+
+1167 
+	`fsh–p_touch
+ (&
+dœ
+->
+Â_¡©
+, 
+TOUCH_ATIME
+, 
+m­time
+);
+
+1169  
+”r
+;
+
+1170 
+	}
+}
+
+	@node.c
+
+22 

+	#_GNU_SOURCE
+
+
+	)
+
+24 
+	~<hurd/Ãtfs.h
+>
+
+25 
+	~<¡dlib.h
+>
+
+26 
+	~<”rÜ.h
+>
+
+27 
+	~<fúŽ.h
+>
+
+28 
+	~<sys/¡©.h
+>
+
+29 
+	~<sys/mmª.h
+>
+
+30 
+	~<¡dio.h
+>
+
+32 
+	~"uniÚfs.h
+"
+
+33 
+	~"node.h
+"
+
+34 
+	~"ulfs.h
+"
+
+35 
+	~"lib.h
+"
+
+41 
+node_ulfs_ä“
+ (
+node_t
+ *
+node
+);
+
+45 
+”rÜ_t
+
+
+46 
+	$node_ü—‹
+ (
+Êode_t
+ *
+Êode
+, 
+node_t
+ **
+node
+)
+
+48 
+Êode_t
+ *
+Êode_Ãw
+ = 
+	`m®loc
+ ( (netnode_t));
+
+49 
+”rÜ_t
+ 
+”r
+ = 0;
+
+50 
+node_t
+ *
+node_Ãw
+;
+
+52 
+	`debug_msg
+ ("node_ü—‹ f܆node: %s", 
+Êode
+->
+Çme
+);
+
+54 ià(! 
+Êode_Ãw
+)
+
+56 
+”r
+ = 
+ENOMEM
+;
+
+57  
+”r
+;
+
+60 
+node_Ãw
+ = 
+	`Ãtfs_make_node
+ (
+Êode_Ãw
+);
+
+61 ià(! 
+node_Ãw
+)
+
+63 
+”r
+ = 
+ENOMEM
+;
+
+64 
+	`ä“
+ (
+Êode_Ãw
+);
+
+65  
+”r
+;
+
+68 
+node_Ãw
+->
+Â
+->
+ulfs
+ = 
+NULL
+;
+
+70 
+”r
+ = 
+	`node_ulfs_š™
+ (
+node_Ãw
+);
+
+71 ià(
+”r
+)
+
+73 
+	`node_de¡roy
+ (
+node_Ãw
+);
+
+74  
+”r
+;
+
+77 
+Êode
+->
+node
+ = 
+node_Ãw
+;
+
+78 
+	`Êode_»f_add
+ (
+Êode
+);
+
+79 
+node_Ãw
+->
+Â
+->
+Êode
+ =†node;
+
+80 
+node_Ãw
+->
+Â
+->
+æags
+ = 0;
+
+81 
+node_Ãw
+->
+Â
+->
+nÿche_Ãxt
+ = 
+NULL
+;
+
+82 
+node_Ãw
+->
+Â
+->
+nÿche_´ev
+ = 
+NULL
+;
+
+83 *
+node
+ = 
+node_Ãw
+;
+
+85  
+”r
+;
+
+86 
+	}
+}
+
+91 
+	$node_de¡roy
+ (
+node_t
+ *
+node
+)
+
+93 
+	`debug_msg
+ ("nod�de¡roy: %s", 
+node
+->
+Â
+->
+Êode
+->
+Çme
+);
+
+94 
+	`as£¹
+ (! (
+node
+->
+Â
+->
+nÿche_Ãxt
+ ||‚ode->Â->
+nÿche_´ev
+));
+
+95 
+	`node_ulfs_ä“
+ (
+node
+);
+
+96 
+	`mu‹x_lock
+ (&
+node
+->
+Â
+->
+Êode
+->
+lock
+);
+
+97 
+node
+->
+Â
+->
+Êode
+->nod�ð
+NULL
+;
+
+98 
+	`Êode_»f_»move
+ (
+node
+->
+Â
+->
+Êode
+);
+
+99 
+	`ä“
+ (
+node
+->
+Â
+);
+
+100 
+	`ä“
+ (
+node
+);
+
+101 
+	}
+}
+
+105 
+”rÜ_t
+
+
+106 
+	$node_upd©e
+ (
+node_t
+ *
+node
+)
+
+108 
+”rÜ_t
+ 
+”r
+ = 0;
+
+109 *
+·th
+;
+
+111 
+node_ulfs_t
+ *
+roÙ_ulfs
+;
+
+112 
+¡©
+ stat;
+
+113 
+fže_t
+ 
+pÜt
+;
+
+114 
+i
+ = 0;
+
+116 
+	`debug_msg
+ ("node_upd©�f܆node: %s", 
+node
+->
+Â
+->
+Êode
+->
+Çme
+);
+
+118 ià(
+	`node_is_roÙ
+ (
+node
+))
+
+119  
+”r
+;
+
+121 
+	`mu‹x_lock
+ (&
+Ãtfs_roÙ_node
+->
+lock
+);
+
+123 
+”r
+ = 
+	`Êode_·th_cÚ¡ruù
+ (
+node
+->
+Â
+->
+Êode
+, &
+·th
+);
+
+124 ià(
+”r
+)
+
+126 
+	`mu‹x_uÆock
+ (&
+Ãtfs_roÙ_node
+->
+lock
+);
+
+127  
+”r
+;
+
+130 
+roÙ_ulfs
+ = 
+Ãtfs_roÙ_node
+->
+Â
+->
+ulfs
+;
+
+132 
+	`node_ulfs_™”©e_uÆocked
+ (
+node
+)
+
+135 ià(
+node_ulfs
+->
+æags
+ & 
+FLAG_NODE_ULFS_FIXED
+)
+
+137 
+i
+++;
+
+142 ià(
+	`pÜt_v®id
+ (
+node_ulfs
+->
+pÜt
+))
+
+143 
+	`pÜt_d—Îoc
+ (
+node_ulfs
+->
+pÜt
+);
+
+145 
+”r
+ = 
+	`fže_lookup
+ ((
+roÙ_ulfs
+ + 
+i
+)->
+pÜt
+, 
+·th
+,
+
+146 
+O_READ
+ | 
+O_NOTRANS
+, O_NOTRANS,
+
+147 0, &
+pÜt
+, &
+¡©
+);
+
+149 ià(
+”r
+)
+
+151 
+node_ulfs
+->
+pÜt
+ = 
+MACH_PORT_NULL
+;
+
+152 
+”r
+ = 0;
+
+153 
+i
+++;
+
+157 ià(
+¡©
+.
+¡_šo
+ =ð
+und”lyšg_node_¡©
+.st_ino
+
+158 && 
+¡©
+.
+¡_fsid
+ =ð
+und”lyšg_node_¡©
+.st_fsid)
+
+160 
+”r
+ = 
+ELOOP
+;
+
+163 
+	`pÜt_d—Îoc
+ (
+pÜt
+);
+
+164 
+”r
+ = 
+	`fže_lookup
+ ((
+roÙ_ulfs
+ + 
+i
+)->
+pÜt
+, 
+·th
+,
+
+165 
+O_READ
+, 0, 0, &
+pÜt
+, &
+¡©
+);
+
+168 ià(
+”r
+)
+
+170 
+pÜt
+ = 
+MACH_PORT_NULL
+;
+
+171 
+”r
+ = 0;
+
+173 
+node_ulfs
+->
+pÜt
+ =…ort;
+
+175 
+i
+++;
+
+178 
+	`ä“
+ (
+·th
+);
+
+179 
+node
+->
+Â
+->
+æags
+ |ð
+FLAG_NODE_ULFS_UPTODATE
+;
+
+181 
+	`mu‹x_uÆock
+ (&
+Ãtfs_roÙ_node
+->
+lock
+);
+
+183  
+”r
+;
+
+184 
+	}
+}
+
+188 
+”rÜ_t
+
+
+189 
+	$node_dœ_»move
+ (
+node_t
+ *
+dœ
+, *
+Çme
+)
+
+191 
+”rÜ_t
+ 
+”r
+ = 0;
+
+193 
+	`node_ulfs_™”©e_»v”£_uÆocked
+ (
+dœ
+)
+
+195 ià(!
+	`pÜt_v®id
+ (
+node_ulfs
+->
+pÜt
+))
+
+198 
+”r
+ = 
+	`dœ_rmdœ
+ (
+node_ulfs
+->
+pÜt
+, 
+Çme
+);
+
+199 ià((
+”r
+è&& (”¸!ð
+ENOENT
+))
+
+203  
+”r
+;
+
+204 
+	}
+}
+
+208 
+”rÜ_t
+
+
+209 
+	$node_dœ_ü—‹
+ (
+node_t
+ *
+dœ
+, *
+Çme
+, 
+mode_t
+ 
+mode
+)
+
+211 
+”rÜ_t
+ 
+”r
+ = 0;
+
+213 
+	`node_ulfs_™”©e_uÆocked
+ (
+dœ
+)
+
+215 ià(!
+	`pÜt_v®id
+ (
+node_ulfs
+->
+pÜt
+))
+
+218 
+”r
+ = 
+	`dœ_mkdœ
+ (
+node_ulfs
+->
+pÜt
+, 
+Çme
+, 
+mode
+);
+
+220 ià((!
+”r
+è|| (”¸=ð
+EEXIST
+è|| (”¸=ð
+ENOTDIR
+))
+
+224  
+”r
+;
+
+225 
+	}
+}
+
+229 
+”rÜ_t
+
+
+230 
+	$node_uÆšk_fže
+ (
+node_t
+ *
+dœ
+, *
+Çme
+)
+
+232 
+mach_pÜt_t
+ 
+p
+;
+
+233 
+¡©
+ stat;
+
+234 
+”rÜ_t
+ 
+”r
+ = 0;
+
+235 
+»moved
+ = 0;
+
+242 
+	`node_ulfs_™”©e_»v”£_uÆocked
+ (
+dœ
+)
+
+245 ià(!
+	`pÜt_v®id
+ (
+node_ulfs
+->
+pÜt
+))
+
+248 
+”r
+ = 
+	`fže_lookup
+ (
+node_ulfs
+->
+pÜt
+, 
+Çme
+,
+
+249 
+O_NOTRANS
+, O_NOTRANS,
+
+250 0, &
+p
+, &
+¡©
+);
+
+252 
+	`pÜt_d—Îoc
+ (
+p
+);
+
+254 ià(
+”r
+ =ð
+ENOENT
+)
+
+256 
+”r
+ = 0;
+
+260 ià(
+”r
+)
+
+263 
+”r
+ = 
+	`dœ_uÆšk
+ (
+node_ulfs
+->
+pÜt
+, 
+Çme
+);
+
+264 ià((
+”r
+è&& (”¸!ð
+ENOENT
+))
+
+267 ià(!
+”r
+)
+
+268 
+»moved
+++;
+
+272 ià((!
+”r
+è&& (!
+»moved
+))
+
+273 
+”r
+ = 
+ENOENT
+;
+
+275  
+”r
+;
+
+276 
+	}
+}
+
+281 
+”rÜ_t
+
+
+282 
+	$node_lookup_fže
+ (
+node_t
+ *
+dœ
+, *
+Çme
+, 
+æags
+,
+
+283 
+fže_t
+ *
+pÜt
+, 
+¡©
+ *
+s
+)
+
+285 
+”rÜ_t
+ 
+”r
+ = 
+ENOENT
+;
+
+286 
+¡©
+ stat;
+
+287 
+fže_t
+ 
+p
+;
+
+289 
+	`node_ulfs_™”©e_uÆocked
+ (
+dœ
+)
+
+292 ià(
+”r
+ !ð
+ENOENT
+)
+
+295 ià(!
+	`pÜt_v®id
+ (
+node_ulfs
+->
+pÜt
+))
+
+298 
+”r
+ = 
+	`fže_lookup
+ (
+node_ulfs
+->
+pÜt
+, 
+Çme
+,
+
+299 
+æags
+ | 
+O_NOTRANS
+, O_NOTRANS,
+
+300 0, &
+p
+, &
+¡©
+);
+
+301 ià(
+”r
+)
+
+304 ià(
+¡©
+.
+¡_šo
+ =ð
+und”lyšg_node_¡©
+.st_ino
+
+305 && 
+¡©
+.
+¡_fsid
+ =ð
+und”lyšg_node_¡©
+.st_fsid)
+
+307 
+”r
+ = 
+ELOOP
+;
+
+311 
+	`pÜt_d—Îoc
+ (
+p
+);
+
+312 
+”r
+ = 
+	`fže_lookup
+ (
+node_ulfs
+->
+pÜt
+, 
+Çme
+,
+
+313 
+æags
+, 0, 0, &
+p
+, &
+¡©
+);
+
+317 ià(! 
+”r
+)
+
+319 *
+s
+ = 
+¡©
+;
+
+320 *
+pÜt
+ = 
+p
+;
+
+323  
+”r
+;
+
+324 
+	}
+}
+
+329 
+	$node_ulfs_ä“
+ (
+node_t
+ *
+node
+)
+
+332 
+	`node_ulfs_™”©e_uÆocked
+ (
+node
+)
+
+334 ià(
+	`pÜt_v®id
+ (
+node_ulfs
+->
+pÜt
+)
+
+335 && 
+node_ulfs
+->
+pÜt
+ !ð
+und”lyšg_node
+)
+
+336 
+	`pÜt_d—Îoc
+ (
+node_ulfs
+->
+pÜt
+);
+
+339 
+	`ä“
+ (
+node
+->
+Â
+->
+ulfs
+);
+
+340 
+	}
+}
+
+344 
+”rÜ_t
+
+
+345 
+	$node_ulfs_š™
+ (
+node_t
+ *
+node
+)
+
+347 
+node_ulfs_t
+ *
+ulfs_Ãw
+;
+
+348 
+”rÜ_t
+ 
+”r
+ = 0;
+
+350 
+ulfs_Ãw
+ = 
+	`m®loc
+ (
+ulfs_num
+ *  (
+node_ulfs_t
+));
+
+351 ià(! 
+ulfs_Ãw
+)
+
+353 
+”r
+ = 
+ENOMEM
+;
+
+354  
+”r
+;
+
+357 ià(
+node
+->
+Â
+->
+ulfs
+)
+
+358 
+	`node_ulfs_ä“
+ (
+node
+);
+
+360 
+node
+->
+Â
+->
+ulfs
+ = 
+ulfs_Ãw
+;
+
+361 
+node
+->
+Â
+->
+ulfs_num
+ = ulfs_num;
+
+363 
+	`node_ulfs_™”©e_uÆocked
+ (
+node
+)
+
+365 
+node_ulfs
+->
+æags
+ = 0;
+
+366 
+node_ulfs
+->
+pÜt
+ = 
+pÜt_nuÎ
+;
+
+369  
+”r
+;
+
+370 
+	}
+}
+
+374 
+”rÜ_t
+
+
+375 
+	$node_’Œ›s_g‘
+ (
+node_t
+ *
+node
+, 
+node_dœ’t_t
+ **
+dœ’ts
+)
+
+377 
+dœ’t
+ **
+dœ’t_li¡
+, **dirent;
+
+378 
+node_dœ’t_t
+ *
+node_dœ’t_li¡
+ = 
+NULL
+;
+
+379 
+size_t
+ 
+dœ’t_d©a_size
+;
+
+380 *
+dœ’t_d©a
+;
+
+381 
+”rÜ_t
+ 
+”r
+ = 0;
+
+386 
+”rÜ_t
+ 
+	`node_dœ’t_add
+ (*
+Çme
+, 
+šo_t
+ 
+fž’o
+, 
+ty³
+)
+
+388 
+”rÜ_t
+ 
+e
+ = 0;
+
+389 
+node_dœ’t_t
+ *
+node_dœ’t
+;
+
+390 
+node_dœ’t_t
+ *
+node_dœ’t_Ãw
+;
+
+391 
+dœ’t
+ *
+dœ’t_Ãw
+;
+
+392 
+Çme_Ën
+ = 
+	`¡¾’
+ (
+Çme
+);
+
+393 
+size
+ = 
+	`DIRENT_LEN
+ (
+Çme_Ën
+);
+
+396 
+node_dœ’t
+ = 
+node_dœ’t_li¡
+;
+
+397 
+node_dœ’t
+ && 
+	`¡rcmp
+ (node_dœ’t->
+dœ’t
+->
+d_Çme
+, 
+Çme
+);
+
+398 
+node_dœ’t
+ =‚ode_dœ’t->
+Ãxt
+);
+
+400 ià(
+node_dœ’t
+)
+
+404 
+node_dœ’t
+->
+dœ’t
+->
+d_fž’o
+ = 
+fž’o
+;
+
+405 
+node_dœ’t
+->
+dœ’t
+->
+d_ty³
+ = 
+ty³
+;
+
+406  
+e
+;
+
+411 
+node_dœ’t_Ãw
+ = 
+	`m®loc
+ ( (
+node_dœ’t_t
+));
+
+412 ià(!
+node_dœ’t_Ãw
+)
+
+414 
+e
+ = 
+ENOMEM
+;
+
+415  
+e
+;
+
+418 
+dœ’t_Ãw
+ = 
+	`m®loc
+ (
+size
+);
+
+419 ià(!
+dœ’t_Ãw
+)
+
+421 
+	`ä“
+ (
+node_dœ’t_Ãw
+);
+
+422 
+e
+ = 
+ENOMEM
+;
+
+423  
+e
+;
+
+427 
+dœ’t_Ãw
+->
+d_fž’o
+ = 
+fž’o
+;
+
+428 
+dœ’t_Ãw
+->
+d_ty³
+ = 
+ty³
+;
+
+429 
+dœ’t_Ãw
+->
+d_»þ’
+ = 
+size
+;
+
+430 
+	`¡rýy
+ ((*è
+dœ’t_Ãw
+ + 
+DIRENT_NAME_OFFS
+, 
+Çme
+);
+
+433 
+node_dœ’t_Ãw
+->
+dœ’t
+ = 
+dœ’t_Ãw
+;
+
+434 
+node_dœ’t_Ãw
+->
+Ãxt
+ = 
+node_dœ’t_li¡
+;
+
+435 
+node_dœ’t_li¡
+ = 
+node_dœ’t_Ãw
+;
+
+437  
+e
+;
+
+440 
+	`node_ulfs_™”©e_uÆocked
+(
+node
+)
+
+442 ià(!
+	`pÜt_v®id
+ (
+node_ulfs
+->
+pÜt
+))
+
+445 
+”r
+ = 
+	`dœ_’Œ›s_g‘
+ (
+node_ulfs
+->
+pÜt
+, &
+dœ’t_d©a
+,
+
+446 &
+dœ’t_d©a_size
+, &
+dœ’t_li¡
+);
+
+447 ià(
+”r
+)
+
+450 
+dœ’t
+ = 
+dœ’t_li¡
+; (! 
+”r
+) && *dirent; dirent++)
+
+451 ià(
+	`¡rcmp
+ ((*
+dœ’t
+)->
+d_Çme
+, ".")
+
+452 && 
+	`¡rcmp
+ ((*
+dœ’t
+)->
+d_Çme
+, ".."))
+
+453 
+”r
+ = 
+	`node_dœ’t_add
+ ((*
+dœ’t
+)->
+d_Çme
+,
+
+454 (*
+dœ’t
+)->
+d_fž’o
+,
+
+455 (*
+dœ’t
+)->
+d_ty³
+);
+
+457 
+	`ä“
+ (
+dœ’t_li¡
+);
+
+458 
+	`munm­
+ (
+dœ’t_d©a
+, 
+dœ’t_d©a_size
+);
+
+461 ià(
+”r
+)
+
+462 
+	`node_’Œ›s_ä“
+ (
+node_dœ’t_li¡
+);
+
+464 *
+dœ’ts
+ = 
+node_dœ’t_li¡
+;
+
+466  
+”r
+;
+
+467 
+	}
+}
+
+471 
+	$node_’Œ›s_ä“
+ (
+node_dœ’t_t
+ *
+dœ’ts
+)
+
+473 
+node_dœ’t_t
+ *
+dœ’t
+, *
+dœ’t_Ãxt
+;
+
+475 
+dœ’t
+ = 
+dœ’ts
+; dœ’t; dœ’ˆð
+dœ’t_Ãxt
+)
+
+477 
+dœ’t_Ãxt
+ = 
+dœ’t
+->
+Ãxt
+;
+
+478 
+	`ä“
+ (
+dœ’t
+->dirent);
+
+479 
+	`ä“
+ (
+dœ’t
+);
+
+481 
+	}
+}
+
+485 
+”rÜ_t
+
+
+486 
+	$node_ü—‹_roÙ
+ (
+node_t
+ **
+roÙ_node
+)
+
+488 
+Êode_t
+ *
+Êode
+;
+
+489 
+node_t
+ *
+node
+;
+
+490 
+”rÜ_t
+ 
+”r
+ = 0;
+
+492 
+”r
+ = 
+	`Êode_ü—‹
+ (
+NULL
+, &
+Êode
+);
+
+493 ià(
+”r
+)
+
+494  
+”r
+;
+
+496 
+”r
+ = 
+	`node_ü—‹
+ (
+Êode
+, &
+node
+);
+
+497 ià(
+”r
+)
+
+499 
+	`Êode_de¡roy
+ (
+Êode
+);
+
+500  
+”r
+;
+
+503 
+	`mu‹x_uÆock
+ (&
+Êode
+->
+lock
+);
+
+504 *
+roÙ_node
+ = 
+node
+;
+
+505  
+”r
+;
+
+506 
+	}
+}
+
+511 
+”rÜ_t
+
+
+512 
+	$node_š™_roÙ
+ (
+node_t
+ *
+node
+)
+
+514 
+”rÜ_t
+ 
+”r
+;
+
+515 
+ulfs_t
+ *
+ulfs
+;
+
+516 
+i
+ = 0;
+
+518 
+	`mu‹x_lock
+ (&
+ulfs_lock
+);
+
+520 
+”r
+ = 
+	`node_ulfs_š™
+ (
+node
+);
+
+521 ià(
+”r
+)
+
+523 
+	`mu‹x_uÆock
+ (&
+ulfs_lock
+);
+
+524  
+”r
+;
+
+527 
+	`node_ulfs_™”©e_uÆocked
+ (
+node
+)
+
+530 ià(
+”r
+)
+
+533 
+”r
+ = 
+	`ulfs_g‘_num
+ (
+i
+, &
+ulfs
+);
+
+534 ià(
+”r
+)
+
+537 ià(
+ulfs
+->
+·th
+)
+
+538 
+node_ulfs
+->
+pÜt
+ = 
+	`fže_Çme_lookup
+ (
+ulfs
+->
+·th
+,
+
+539 
+O_READ
+ | 
+O_DIRECTORY
+, 0);
+
+541 
+node_ulfs
+->
+pÜt
+ = 
+und”lyšg_node
+;
+
+543 ià(! 
+	`pÜt_v®id
+ (
+node_ulfs
+->
+pÜt
+))
+
+545 
+”r
+ = 
+Ӽo
+;
+
+549 
+node_ulfs
+->
+æags
+ |ð
+FLAG_NODE_ULFS_FIXED
+;
+
+550 
+i
+++;
+
+553 
+	`mu‹x_uÆock
+ (&
+ulfs_lock
+);
+
+554  
+”r
+;
+
+555 
+	}
+}
+
+	@node.h
+
+22 #iâdeà
+INCLUDED_NODE_H
+
+
+23 

+	#INCLUDED_NODE_H
+
+
+	)
+
+25 
+	~<”rÜ.h
+>
+
+26 
+	~<sys/¡©.h
+>
+
+27 
+	~<hurd/Ãtfs.h
+>
+
+29 
+node
+ 
+	tnode_t
+;
+
+31 
+	~"Êode.h
+"
+
+34 
+	snode_ulfs
+
+
+36 
+	mæags
+;
+
+38 
+fže_t
+ 
+	mpÜt
+;
+
+41 
+node_ulfs
+ 
+	tnode_ulfs_t
+;
+
+46 

+	#FLAG_NODE_ULFS_FIXED
+ 0x00000001
+
+	)
+
+48 
+	sÊode
+
+
+50 
+Êode_t
+ *
+	mÊode
+;
+
+52 
+	mæags
+;
+
+53 
+node_ulfs_t
+ *
+	mulfs
+;
+
+55 
+	mulfs_num
+;
+
+56 
+node_t
+ *
+	mnÿche_Ãxt
+;
+
+57 
+node_t
+ *
+	mnÿche_´ev
+;
+
+59 
+Êode
+ 
+	tÊode_t
+;
+
+62 

+	#FLAG_NODE_INVALIDATE
+ 0x00000001
+
+	)
+
+63 

+	#FLAG_NODE_ULFS_UPTODATE
+ 0x00000002
+
+	)
+
+65 
+	snode_dœ’t
+
+
+67 
+dœ’t
+ *
+	mdœ’t
+;
+
+68 
+node_dœ’t
+ *
+	mÃxt
+;
+
+69 } 
+	tnode_dœ’t_t
+;
+
+73 
+”rÜ_t
+ 
+node_ü—‹
+ (
+Êode_t
+ *
+Êode
+, 
+node_t
+ **
+node
+);
+
+77 
+node_de¡roy
+ (
+node_t
+ *
+node
+);
+
+81 
+”rÜ_t
+ 
+node_upd©e
+ (
+node_t
+ *
+node
+);
+
+85 
+”rÜ_t
+ 
+node_dœ_ü—‹
+ (
+node_t
+ *
+dœ
+, *
+Çme
+, 
+mode_t
+ 
+mode
+);
+
+89 
+”rÜ_t
+ 
+node_dœ_»move
+ (
+node_t
+ *
+dœ
+, *
+Çme
+);
+
+93 
+”rÜ_t
+ 
+node_uÆšk_fže
+ (
+node_t
+ *
+dœ
+, *
+Çme
+);
+
+98 
+”rÜ_t
+ 
+node_lookup_fže
+ (
+node_t
+ *
+dœ
+, *
+Çme
+, 
+æags
+,
+
+99 
+fže_t
+ *
+pÜt
+, 
+¡©
+ *stat);
+
+103 
+”rÜ_t
+ 
+node_ulfs_š™
+ (
+node_t
+ *
+node
+);
+
+107 
+”rÜ_t
+ 
+node_’Œ›s_g‘
+ (
+node_t
+ *
+node
+, 
+node_dœ’t_t
+ **
+dœ’ts
+);
+
+110 
+node_’Œ›s_ä“
+ (
+node_dœ’t_t
+ *
+dœ’ts
+);
+
+114 
+”rÜ_t
+ 
+node_ü—‹_roÙ
+ (
+node_t
+ **
+roÙ_node
+);
+
+118 
+”rÜ_t
+ 
+node_š™_roÙ
+ (
+node_t
+ *
+node
+);
+
+121 

+	#node_is_roÙ
+(
+node
+èÒode)->
+Â
+->
+Êode
+->
+dœ
+ ? 0 : 1
+
+	)
+
+125 

+	#node_ulfs_™”©e_uÆocked
+(
+node
+) \
+
+126 
+node_ulfs_t
+ *
+node_ulfs
+ = (
+node
+)->
+Â
+->
+ulfs
+; \
+
+127 
+node_ulfs
+ < (
+node
+)->
+Â
+->
+ulfs
+ + (node)->Â->
+ulfs_num
+; \
+
+128 
+node_ulfs
+++)
+
+	)
+
+130 

+	#node_ulfs_™”©e_»v”£_uÆocked
+(
+node
+) \
+
+131 
+node_ulfs_t
+ *
+node_ulfs
+ = (
+node
+)->
+Â
+->
+ulfs
+ + (node)->Â->
+ulfs_num
+ - 1;\
+
+132 
+node_ulfs
+ >ð(
+node
+)->
+Â
+->
+ulfs
+; \
+
+133 
+node_ulfs
+--)
+
+	)
+
+	@options.c
+
+22 

+	#_GNU_SOURCE
+
+
+	)
+
+24 
+	~<¬gp.h
+>
+
+25 
+	~<”rÜ.h
+>
+
+27 
+	~"ÝtiÚs.h
+"
+
+28 
+	~"ulfs.h
+"
+
+29 
+	~"nÿche.h
+"
+
+30 
+	~"uniÚfs.h
+"
+
+31 
+	~"node.h
+"
+
+32 
+	~"v”siÚ.h
+"
+
+33 
+	~"·‰”n.h
+"
+
+34 
+	~"¡ow.h
+"
+
+35 
+	~"upd©e.h
+"
+
+41 
+	g·rsšg_¡¬tup_ÝtiÚs_fšished
+;
+
+44 cÚ¡ 
+¬gp_ÝtiÚ
+ 
+	g¬gp_commÚ_ÝtiÚs
+[] =
+
+46 { 
+OPT_LONG_UNDERLYING
+, 
+OPT_UNDERLYING
+, 0, 0,
+
+48 { 
+OPT_LONG_WRITABLE
+, 
+OPT_WRITABLE
+, 0, 0,
+
+50 { 
+OPT_LONG_DEBUG
+, 
+OPT_DEBUG
+, 0, 
+OPTION_HIDDEN
+,
+
+52 { 
+OPT_LONG_CACHE_SIZE
+, 
+OPT_CACHE_SIZE
+, "SIZE", 0,
+
+55 { 
+OPT_LONG_STOW
+, 
+OPT_STOW
+, "STOWDIR", 0,
+
+57 { 
+OPT_LONG_PRIORITY
+, 
+OPT_PRIORITY
+, "VALUE", 0,
+
+59 { 
+OPT_LONG_PATTERN
+, 
+OPT_PATTERN
+, "PATTERN", 0,
+
+61 { 
+OPT_LONG_REMOVE
+, 
+OPT_REMOVE
+, 0, 0,
+
+63 { 
+OPT_LONG_ADD
+, 
+OPT_ADD
+, 0, 0,
+
+69 cÚ¡ 
+¬gp_ÝtiÚ
+ 
+	g¬gp_¡¬tup_ÝtiÚs
+[] =
+
+75 
+”rÜ_t
+
+
+76 
+	$¬gp_·r£_commÚ_ÝtiÚs
+ (
+key
+, *
+¬g
+, 
+¬gp_¡©e
+ *
+¡©e
+)
+
+78 
+ulfs_æags
+ = 0, 
+ulfs_mode
+ = 0, 
+ulfs_modif›d
+ = 0,
+
+79 
+ulfs_m©ch
+ = 0, 
+ulfs_´iÜ™y
+ = 0;
+
+80 
+·‰”Æi¡
+ 
+ulfs_·‰”Æi¡
+ =
+
+82 .
+lock
+ = 
+MUTEX_INITIALIZER
+,
+
+83 .
+h—d
+ = 
+NULL
+
+
+85 
+”rÜ_t
+ 
+”r
+ = 0;
+
+87 
+key
+)
+
+89 
+OPT_WRITABLE
+:
+
+90 
+ulfs_æags
+ |ð
+FLAG_ULFS_WRITABLE
+;
+
+93 
+OPT_PRIORITY
+:
+
+94 
+ulfs_´iÜ™y
+ = 
+	`¡¹Þ
+ (
+¬g
+, 
+NULL
+, 10);
+
+97 
+OPT_DEBUG
+:
+
+98 
+uniÚfs_æags
+ |ð
+FLAG_UNIONFS_MODE_DEBUG
+;
+
+101 
+OPT_CACHE_SIZE
+:
+
+102 
+nÿche_size
+ = 
+	`¡¹Þ
+ (
+¬g
+, 
+NULL
+, 10);
+
+105 
+OPT_ADD
+:
+
+106 
+ulfs_mode
+ = 
+ULFS_MODE_ADD
+;
+
+109 
+OPT_REMOVE
+:
+
+110 
+ulfs_mode
+ = 
+ULFS_MODE_REMOVE
+;
+
+113 
+OPT_PATTERN
+:
+
+114 
+ulfs_m©ch
+ = 1;
+
+115 
+	`·‰”Æi¡_add
+ (&
+ulfs_·‰”Æi¡
+, 
+¬g
+);
+
+118 
+OPT_STOW
+:
+
+119 
+”r
+ = 
+	`¡ow_dœadd
+ (
+¬g
+, 
+ulfs_æags
+, &
+ulfs_·‰”Æi¡
+, 
+ulfs_´iÜ™y
+);
+
+120 ià(
+”r
+)
+
+121 
+	`”rÜ
+ (
+EXIT_FAILURE
+, 
+”r
+, "stow_diradd");
+
+122 
+ulfs_modif›d
+ = 1;
+
+123 
+ulfs_æags
+ = 
+ulfs_mode
+ = 
+ulfs_´iÜ™y
+ = 0;
+
+124 
+ulfs_m©ch
+ = 0;
+
+127 
+OPT_UNDERLYING
+:
+
+128 
+ARGP_KEY_ARG
+:
+
+130 ià(
+ulfs_mode
+ =ð
+ULFS_MODE_REMOVE
+)
+
+132 
+”r
+ = 
+	`ulfs_uÄegi¡”
+ (
+¬g
+);
+
+133 ià(
+”r
+ =ð
+ENOENT
+)
+
+136 
+”r
+ = 0;
+
+139 
+”r
+ = 
+	`ulfs_»gi¡”
+ (
+¬g
+, 
+ulfs_æags
+, 
+ulfs_´iÜ™y
+);
+
+140 ià(
+”r
+)
+
+141 
+	`”rÜ
+ (
+EXIT_FAILURE
+, 
+”r
+, "ulfs_register");
+
+142 
+ulfs_modif›d
+ = 1;
+
+143 
+ulfs_æags
+ = 
+ulfs_mode
+ = 
+ulfs_´iÜ™y
+ = 0;
+
+144 
+ulfs_m©ch
+ = 0;
+
+147 
+ARGP_KEY_END
+:
+
+148 
+ulfs_æags
+ = 
+ulfs_mode
+ = 0;
+
+149 ià(
+ulfs_modif›d
+ && 
+·rsšg_¡¬tup_ÝtiÚs_fšished
+)
+
+151 
+	`roÙ_upd©e_scheduË
+ ();
+
+155 
+	`nÿche_»£t
+ ();
+
+157 
+ulfs_modif›d
+ = 0;
+
+159 ià(! 
+·rsšg_¡¬tup_ÝtiÚs_fšished
+)
+
+160 
+·rsšg_¡¬tup_ÝtiÚs_fšished
+ = 1;
+
+164 
+”r
+ = 
+ARGP_ERR_UNKNOWN
+;
+
+168  
+”r
+;
+
+169 
+	}
+}
+
+172 
+”rÜ_t
+
+
+173 
+	$¬gp_·r£_¡¬tup_ÝtiÚs
+ (
+key
+, *
+¬g
+, 
+¬gp_¡©e
+ *
+¡©e
+)
+
+175 
+”rÜ_t
+ 
+”r
+ = 0;
+
+177 
+key
+)
+
+180 
+”r
+ = 
+ARGP_ERR_UNKNOWN
+;
+
+184  
+”r
+;
+
+185 
+	}
+}
+
+188 cÚ¡ 
+¬gp
+ 
+	g¬gp_·r£r_commÚ_ÝtiÚs
+ =
+
+189 { 
+¬gp_commÚ_ÝtiÚs
+, 
+¬gp_·r£_commÚ_ÝtiÚs
+, 0, 0, 0 };
+
+192 
+¬gp
+ 
+	g¬gp_·r£r_¡¬tup_ÝtiÚs
+ =
+
+193 { 
+¬gp_¡¬tup_ÝtiÚs
+, 
+¬gp_·r£_¡¬tup_ÝtiÚs
+, 0, 0, 0 };
+
+196 cÚ¡ 
+¬gp_chžd
+ 
+	g¬gp_chžd»n_ruÁime
+[] =
+
+198 { &
+¬gp_·r£r_commÚ_ÝtiÚs
+ },
+
+199 { &
+Ãtfs_¡d_ruÁime_¬gp
+ },
+
+204 cÚ¡ 
+¬gp_chžd
+ 
+	g¬gp_chžd»n_¡¬tup
+[] =
+
+206 { &
+¬gp_·r£r_¡¬tup_ÝtiÚs
+ },
+
+207 { &
+¬gp_·r£r_commÚ_ÝtiÚs
+ },
+
+208 { &
+Ãtfs_¡d_¡¬tup_¬gp
+ },
+
+212 cÚ¡ *
+	g¬gp_´og¿m_v”siÚ
+ = 
+STANDARD_HURD_VERSION
+ (
+uniÚfs
+);
+
+213 cÚ¡ *
+	g¬gp_´og¿m_bug_add»ss
+ =
+
+216 

+	#ARGS_DOC
+ "FILESYSTEMS ..."
+
+	)
+
+217 

+	#DOC
+ "Hurd uniÚf £rv”"
+
+	)
+
+220 
+¬gp
+ 
+	g¬gp_ruÁime
+ =
+
+221 { 0, 0, 0, 0, 
+¬gp_chžd»n_ruÁime
+ };
+
+224 
+¬gp
+ 
+	g¬gp_¡¬tup
+ =
+
+225 { 0, 0, 
+ARGS_DOC
+, 
+DOC
+, 
+¬gp_chžd»n_¡¬tup
+ };
+
+	@options.h
+
+23 

+	#OPT_UNDERLYING
+ 'u'
+
+	)
+
+24 

+	#OPT_WRITABLE
+ 'w'
+
+	)
+
+25 

+	#OPT_DEBUG
+ 'd'
+
+	)
+
+26 

+	#OPT_CACHE_SIZE
+ 'c'
+
+	)
+
+27 

+	#OPT_REMOVE
+ 'r'
+
+	)
+
+28 

+	#OPT_ADD
+ 'a'
+
+	)
+
+29 

+	#OPT_PATTERN
+ 'm'
+
+	)
+
+30 

+	#OPT_PRIORITY
+ 'p'
+
+	)
+
+31 

+	#OPT_STOW
+ 's'
+
+	)
+
+34 

+	#OPT_LONG_UNDERLYING
+ "und”lyšg"
+
+	)
+
+35 

+	#OPT_LONG_WRITABLE
+ "wr™abË"
+
+	)
+
+36 

+	#OPT_LONG_DEBUG
+ "debug"
+
+	)
+
+37 

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

+	#OPT_LONG_REMOVE
+ "»move"
+
+	)
+
+39 

+	#OPT_LONG_ADD
+ "add"
+
+	)
+
+40 

+	#OPT_LONG_PATTERN
+ "m©ch"
+
+	)
+
+41 

+	#OPT_LONG_PRIORITY
+ "´iÜ™y"
+
+	)
+
+42 

+	#OPT_LONG_STOW
+ "¡ow"
+
+	)
+
+44 

+	#OPT_LONG
+(
+o
+è"--" 
+	)
+o
+
+47 

+¬gp
+ 
+¬gp_¡¬tup
+;
+
+50 

+¬gp
+ 
+¬gp_ruÁime
+;
+
+52 

+	#ULFS_MODE_ADD
+ 0
+
+	)
+
+53 

+	#ULFS_MODE_REMOVE
+ 1
+
+	)
+
+	@pattern.c
+
+22 

+	#_GNU_SOURCE
+
+
+	)
+
+24 
+	~<hurd/Ãtfs.h
+>
+
+25 
+	~<¡dlib.h
+>
+
+26 
+	~<âm©ch.h
+>
+
+27 
+	~<Ӽo.h
+>
+
+29 
+	~"·‰”n.h
+"
+
+32 
+”rÜ_t
+
+
+33 
+	$·‰”Æi¡_add
+ (
+·‰”Æi¡
+ *
+li¡
+, *
+·‰”n
+)
+
+35 
+”rÜ_t
+ 
+”r
+ = 0;
+
+36 
+·‰”n
+ *
+li¡’Œy
+;
+
+37 *
+dup
+;
+
+39 ià(
+·‰”n
+ =ð
+NULL
+)
+
+40 
+”r
+ = 
+EINVAL
+;
+
+42 ià(
+”r
+)
+
+43  
+”r
+;
+
+45 
+dup
+ = 
+	`¡rdup
+ (
+·‰”n
+);
+
+46 ià(
+dup
+ =ð
+NULL
+)
+
+47 
+”r
+ = 
+ENOMEM
+;
+
+49 ià(
+”r
+)
+
+50  
+”r
+;
+
+52 
+li¡’Œy
+ = 
+	`m®loc
+ ( (
+·‰”n
+));
+
+53 ià(
+li¡’Œy
+ =ð
+NULL
+)
+
+54 
+”r
+ = 
+ENOMEM
+;
+
+56 ià(
+”r
+)
+
+57  
+”r
+;
+
+59 
+li¡’Œy
+->
+·‰”n
+ = 
+dup
+;
+
+61 
+	`mu‹x_lock
+ (& (
+li¡
+->
+lock
+));
+
+62 ià(
+li¡
+->
+h—d
+ =ð
+NULL
+)
+
+64 
+li¡
+->
+h—d
+ = 
+li¡’Œy
+;
+
+65 
+li¡’Œy
+->
+Ãxt
+ = 
+NULL
+;
+
+69 
+li¡’Œy
+->
+Ãxt
+ = 
+li¡
+->
+h—d
+;
+
+70 
+li¡
+->
+h—d
+ = 
+li¡’Œy
+;
+
+72 
+	`mu‹x_uÆock
+ (& (
+li¡
+->
+lock
+));
+
+74  
+”r
+;
+
+75 
+	}
+}
+
+80 
+	$·‰”Æi¡_m©ch
+ (
+·‰”Æi¡
+ *
+li¡
+, *
+¡ršg
+)
+
+82 
+·‰”n
+ *
+±r
+;
+
+83 
+”rÜ_t
+ 
+”r
+ = ~0;
+
+85 
+±r
+ = 
+li¡
+->
+h—d
+;
+
+87 
+	`mu‹x_lock
+ (&
+li¡
+->
+lock
+);
+
+88 
+±r
+ !ð
+NULL
+)
+
+90 
+”r
+ = 
+	`âm©ch
+ (
+±r
+->
+·‰”n
+, 
+¡ršg
+, 
+FNM_FILE_NAME
+);
+
+92 ià(!
+”r
+)
+
+95 
+±r
+ =…Œ->
+Ãxt
+;
+
+97 
+	`mu‹x_uÆock
+ (&
+li¡
+->
+lock
+);
+
+99  
+”r
+;
+
+100 
+	}
+}
+
+104 
+	$·‰”Æi¡_de¡roy
+ (
+·‰”Æi¡
+ *
+li¡
+)
+
+106 
+·‰”n
+ *
+Ãxt
+, *
+±r
+ = 
+li¡
+->
+h—d
+;
+
+108 
+	`mu‹x_lock
+ (& (
+li¡
+->
+lock
+));
+
+109 
+±r
+ !ð
+NULL
+)
+
+111 
+Ãxt
+ = 
+±r
+->next;
+
+113 
+	`ä“
+ (
+±r
+);
+
+115 
+±r
+ = 
+Ãxt
+;
+
+117 
+	`mu‹x_uÆock
+ (& (
+li¡
+->
+lock
+));
+
+118 
+	}
+}
+
+122 
+	$·‰”Æi¡_i£m±y
+ (
+·‰”Æi¡
+ *
+li¡
+)
+
+124 
+»t
+;
+
+126 
+	`mu‹x_lock
+ (& (
+li¡
+->
+lock
+));
+
+127 
+»t
+ = (
+li¡
+->
+h—d
+ =ð
+NULL
+);
+
+128 
+	`mu‹x_uÆock
+ (& (
+li¡
+->
+lock
+));
+
+130  
+»t
+;
+
+131 
+	}
+}
+
+	@pattern.h
+
+22 #iâdeà
+_PATTERN_H
+
+
+23 

+	#_PATTERN_H
+
+
+	)
+
+25 
+	~<hurd/Ãtfs.h
+>
+
+27 
+	s·‰”n
+
+
+29 *
+	m·‰”n
+;
+
+31 
+·‰”n
+ *
+	mÃxt
+;
+
+34 
+	s·‰”Æi¡
+
+
+36 
+mu‹x
+ 
+	mlock
+;
+
+37 
+·‰”n
+ *
+	mh—d
+;
+
+41 

+”rÜ_t
+ 
+·‰”Æi¡_add
+ (
+·‰”Æi¡
+ *
+li¡
+, *
+·‰”n
+);
+
+45 

+·‰”Æi¡_m©ch
+ (
+·‰”Æi¡
+ *
+li¡
+, *
+¡ršg
+);
+
+48 

+·‰”Æi¡_de¡roy
+ (
+·‰”Æi¡
+ *
+li¡
+);
+
+51 

+·‰”Æi¡_i£m±y
+ (
+·‰”Æi¡
+ *
+li¡
+);
+
+	@stow-mutations.h
+
+23 

+	#FS_NOTIFY_INTRAN
+ 
+¡ow_nÙify_t
+ 
+	`begš_usšg_nÙify_pÜt
+ (
+fs_nÙify_t
+)
+
+	)
+
+24 

+	#FS_NOTIFY_DESTRUCTOR
+ 
+	`’d_usšg_nÙify_pÜt
+ (
+¡ow_nÙify_t
+)
+
+	)
+
+26 

+	#FS_NOTIFY_IMPORTS
+ 
+impÜt
+ "¡ow-´iv.h";
+
+	)
+
+	@stow-priv.h
+
+20 #iâdeà
+__STOW_PRIVDATA_H__
+
+
+21 

+	#__STOW_PRIVDATA_H__
+
+
+	)
+
+23 
+	~<hurd/pÜts.h
+>
+
+25 
+	s¡ow_nÙify
+
+
+27 
+pÜt_šfo
+ 
+	mpi
+;
+
+29 *
+	mdœ_Çme
+;
+
+30 
+¡ow_´ivd©a
+ *
+	m´iv
+;
+
+32 
+¡ow_nÙify
+ *
+	t¡ow_nÙify_t
+;
+
+37 
+¡ow_nÙify_t
+ 
+begš_usšg_nÙify_pÜt
+ (
+fs_nÙify_t
+ 
+pÜt
+);
+
+43 
+’d_usšg_nÙify_pÜt
+ (
+¡ow_nÙify_t
+ 
+üed
+);
+
+	@stow.c
+
+23 

+	#_GNU_SOURCE
+
+
+	)
+
+25 
+	~<¬gp.h
+>
+
+26 
+	~<”rÜ.h
+>
+
+28 
+	~"ulfs.h
+"
+
+29 
+	~"lib.h
+"
+
+30 
+	~"·‰”n.h
+"
+
+31 
+	~"upd©e.h
+"
+
+33 
+	s¡ow_´ivd©a
+
+
+35 
+·‰”Æi¡
+ *
+	m·‰”Æi¡
+;
+
+36 
+	mæags
+;
+
+37 
+	m´iÜ™y
+;
+
+38 
+mu‹x
+ 
+	mlock
+;
+
+41 
+”rÜ_t
+
+
+42 
+	$_¡ow_»gi¡”m©chšgdœs
+ (*
+¬g
+, *
+dœ·th
+, *
+´iv
+)
+
+44 
+”rÜ_t
+ 
+”r
+ = 0;
+
+45 *
+fž•©h
+;
+
+47 
+¡ow_´ivd©a
+ *
+´ivd©a
+ = (¡ow_´ivd©¨*è
+´iv
+ ;
+
+49 
+”r
+ = 
+	`·‰”Æi¡_m©ch
+ (
+´ivd©a
+->
+·‰”Æi¡
+, 
+¬g
+);
+
+50 ià(
+”r
+)
+
+53 
+fž•©h
+ = 
+	`make_fž•©h
+ (
+dœ·th
+, 
+¬g
+);
+
+55 
+”r
+ = 
+	`ulfs_»gi¡”
+ (
+fž•©h
+, 
+´ivd©a
+->
+æags
+,…rivd©a->
+´iÜ™y
+);
+
+57 
+	`ä“
+ (
+fž•©h
+);
+
+59 ià(
+”r
+)
+
+60  
+”r
+;
+
+63 
+	}
+}
+
+65 
+”rÜ_t
+
+
+66 
+	$_¡ow_sÿn¡ow’Œy
+ (*
+¬g
+, *
+dœ·th
+, *
+´iv
+)
+
+68 *
+fž•©h
+ = 
+dœ·th
+;
+
+69 
+”rÜ_t
+ 
+”r
+;
+
+71 
+¡ow_´ivd©a
+ *
+´ivd©a
+ = (¡ow_´ivd©¨*è
+´iv
+ ;
+
+73 ià(
+dœ·th
+)
+
+75 *
+tmp
+;
+
+76 
+tmp
+ = 
+	`make_fž•©h
+ (
+dœ·th
+, 
+¬g
+);
+
+77 
+fž•©h
+ = 
+	`make_fž•©h
+ (
+tmp
+, "/");
+
+78 
+	`ä“
+ (
+tmp
+);
+
+81 
+	`mu‹x_lock
+ (&
+´ivd©a
+->
+lock
+);
+
+83 ià(
+	`·‰”Æi¡_i£m±y
+ (
+´ivd©a
+->
+·‰”Æi¡
+))
+
+86 
+”r
+ = 
+	`ulfs_»gi¡”
+ (
+fž•©h
+, 
+´ivd©a
+->
+æags
+,…rivd©a->
+´iÜ™y
+);
+
+87 ià(
+”r
+)
+
+89 
+	`mu‹x_uÆock
+ (&
+´ivd©a
+->
+lock
+);
+
+90  
+”r
+;
+
+96 
+”r
+ = 
+	`fÜ_—ch_subdœ_´iv
+ (
+fž•©h
+, 
+_¡ow_»gi¡”m©chšgdœs
+, 
+´iv
+);
+
+97 ià(
+”r
+)
+
+99 
+	`mu‹x_uÆock
+ (&
+´ivd©a
+->
+lock
+);
+
+100 
+	`ä“
+ (
+fž•©h
+);
+
+101  
+”r
+;
+
+105 
+	`ä“
+ (
+fž•©h
+);
+
+106 
+	`mu‹x_uÆock
+ (&
+´ivd©a
+->
+lock
+);
+
+107  
+”r
+;
+
+108 
+	}
+}
+
+113 
+	~<ùh»ads.h
+>
+
+114 
+	~<hurd/pÜt.h
+>
+
+116 
+	~"¡ow-´iv.h
+"
+
+117 
+	~"nÿche.h
+"
+
+119 
+pÜt_buck‘
+ *
+	g¡ow_pÜt_buck‘
+;
+
+120 
+pÜt_þass
+ *
+	g¡ow_pÜt_þass
+;
+
+122 
+”rÜ_t
+
+
+123 
+	$_¡ow_nÙify_š™
+(*
+dœ_Çme
+, *
+´iv
+)
+
+125 
+”rÜ_t
+ 
+”r
+;
+
+126 
+fže_t
+ 
+dœ_pÜt
+;
+
+127 
+mach_pÜt_t
+ 
+nÙify_pÜt
+;
+
+128 
+¡ow_nÙify_t
+ 
+¡ow_nÙify_pÜt
+;
+
+130 
+”r
+ = 
+	`pÜts_ü—‹_pÜt
+ (
+¡ow_pÜt_þass
+, 
+¡ow_pÜt_buck‘
+,
+
+131  (*
+¡ow_nÙify_pÜt
+),
+
+132 &
+¡ow_nÙify_pÜt
+);
+
+133 ià(
+”r
+)
+
+134  
+”r
+;
+
+136 
+¡ow_nÙify_pÜt
+->
+dœ_Çme
+ = dir_name;
+
+137 
+¡ow_nÙify_pÜt
+->
+´iv
+ =…riv;
+
+139 
+dœ_pÜt
+ = 
+	`fže_Çme_lookup
+ (
+dœ_Çme
+, 0, 0);
+
+141 ià(!
+	`pÜt_v®id
+ (
+dœ_pÜt
+))
+
+142  
+ENOENT
+;
+
+145 
+nÙify_pÜt
+ = 
+	`pÜts_g‘_right
+ (
+¡ow_nÙify_pÜt
+);
+
+147 ià(!
+	`pÜt_v®id
+ (
+nÙify_pÜt
+))
+
+149 
+	`pÜt_d—Îoc
+ (
+dœ_pÜt
+);
+
+150  
+EACCES
+;
+
+153 
+”r
+ = 
+	`dœ_nÙiû_chªges
+ (
+dœ_pÜt
+, 
+nÙify_pÜt
+,
+
+154 
+MACH_MSG_TYPE_MAKE_SEND
+);
+
+155 ià(
+”r
+)
+
+157 
+	`pÜt_d—Îoc
+ (
+dœ_pÜt
+);
+
+158 
+	`pÜt_d—Îoc
+ (
+nÙify_pÜt
+);
+
+159  
+”r
+;
+
+162  
+”r
+;
+
+163 
+	}
+}
+
+167 
+¡ow_nÙify_t
+
+
+168 
+	$begš_usšg_nÙify_pÜt
+ (
+fs_nÙify_t
+ 
+pÜt
+)
+
+170  
+	`pÜts_lookup_pÜt
+ (
+¡ow_pÜt_buck‘
+, 
+pÜt
+, 
+¡ow_pÜt_þass
+);
+
+171 
+	}
+}
+
+177 
+	$’d_usšg_nÙify_pÜt
+ (
+¡ow_nÙify_t
+ 
+üed
+)
+
+179 ià(
+üed
+)
+
+180 
+	`pÜts_pÜt_d”ef
+ (
+üed
+);
+
+181 
+	}
+}
+
+184 
+k”n_»tuº_t
+
+
+185 
+	$¡ow_S_fže_chªged
+ (
+¡ow_nÙify_t
+ 
+nÙify
+, 
+Çtu¿l_t
+ 
+tickno
+,
+
+186 
+fže_chªged_ty³_t
+ 
+chªge
+, 
+loff_t
+ 
+¡¬t
+,
+
+187 
+loff_t
+ 
+’d
+)
+
+189  
+EOPNOTSUPP
+;
+
+190 
+	}
+}
+
+193 
+k”n_»tuº_t
+
+
+194 
+	$¡ow_S_dœ_chªged
+ (
+¡ow_nÙify_t
+ 
+nÙify
+, 
+Çtu¿l_t
+ 
+tickno
+,
+
+195 
+dœ_chªged_ty³_t
+ 
+chªge
+, 
+¡ršg_t
+ 
+Çme
+)
+
+197 
+”rÜ_t
+ 
+”r
+;
+
+199 ià(!
+nÙify
+ || !nÙify->
+dœ_Çme
+ || !nÙify->
+´iv
+)
+
+200  
+EOPNOTSUPP
+;
+
+202 
+chªge
+)
+
+204 
+DIR_CHANGED_NULL
+:
+
+206 
+DIR_CHANGED_NEW
+:
+
+207 
+	`roÙ_upd©e_di§bË
+ ();
+
+209 
+”r
+ = 
+	`_¡ow_sÿn¡ow’Œy
+ (
+Çme
+, 
+nÙify
+->
+dœ_Çme
+,‚Ùify->
+´iv
+);
+
+210 ià(
+”r
+)
+
+211 
+	`debug_msg_£nd
+ ("sÿn¡ow’Œy: %s\n", 
+	`¡»¼Ü
+ (
+”r
+));
+
+213 
+	`roÙ_upd©e_scheduË
+ ();
+
+214 
+	`roÙ_upd©e_’abË
+ ();
+
+217 
+DIR_CHANGED_UNLINK
+:
+
+218 
+	`roÙ_upd©e_scheduË
+ ();
+
+222 
+	`debug_msg_£nd
+ ("unsupported dir change‚otify");
+
+223  
+EINVAL
+;
+
+227 
+	}
+}
+
+231 
+	$_¡ow_nÙify_th»ad
+()
+
+233 
+	`¡ow_demux”
+ (
+mach_msg_h—d”_t
+ *
+šp
+, mach_msg_h—d”_ˆ*
+ou�
+)
+
+235 
+	`¡ow_fs_nÙify_£rv”
+ (
+mach_msg_h—d”_t
+ *
+šp
+,
+
+236 
+mach_msg_h—d”_t
+ *
+ou�
+);
+
+238  (
+	`¡ow_fs_nÙify_£rv”
+ (
+šp
+, 
+ou�
+));
+
+243 
+	`pÜts_mªage_pÜt_Ý”©iÚs_muÉ™h»ad
+ (
+¡ow_pÜt_buck‘
+,
+
+244 
+¡ow_demux”
+,
+
+250 
+	}
+}
+
+256 
+”rÜ_t
+
+
+257 
+	$¡ow_dœadd
+ (*
+dœ
+, 
+æags
+, 
+·‰”Æi¡
+ *patternlist,
+
+258 
+´iÜ™y
+)
+
+261 
+”rÜ_t
+ 
+”r
+;
+
+262 
+¡ow_´ivd©a
+ *
+my´iv
+;
+
+263 
+dœ_Ën
+;
+
+265 
+dœ_Ën
+ = 
+	`¡¾’
+(
+dœ
+);
+
+266 ià(
+dœ_Ën
+ == 0)
+
+268  
+EOPNOTSUPP
+;
+
+271 ià(
+dœ
+[
+dœ_Ën
+ - 1 ] != '/')
+
+273 *
+tmp
+;
+
+275 
+tmp
+ = (*è
+	`m®loc
+ (
+dœ_Ën
+ + 1);
+
+277 ià(
+tmp
+ =ð
+NULL
+)
+
+278  
+ENOMEM
+;
+
+280 
+	`¡ºýy
+ (
+tmp
+, 
+dœ
+, 
+dœ_Ën
+);
+
+282 
+tmp
+[
+dœ_Ën
+] = '/';
+
+284 
+dœ
+ = 
+tmp
+;
+
+287 
+my´iv
+ = 
+	`m®loc
+ ( (
+¡ow_´ivd©a
+));
+
+288 ià(!
+my´iv
+)
+
+290 
+	`ä“
+ (
+dœ
+);
+
+291  
+ENOMEM
+;
+
+294 
+my´iv
+->
+·‰”Æi¡
+ =…atternlist;
+
+295 
+my´iv
+->
+æags
+ = flags;
+
+296 
+my´iv
+->
+´iÜ™y
+ =…riority;
+
+297 
+	`mu‹x_š™
+ (&
+my´iv
+->
+lock
+);
+
+299 
+”r
+ = 
+	`fÜ_—ch_subdœ_´iv
+ (
+dœ
+, 
+_¡ow_sÿn¡ow’Œy
+, (*)
+my´iv
+);
+
+300 ià(
+”r
+)
+
+303  
+”r
+;
+
+306 
+”r
+ = 
+	`_¡ow_nÙify_š™
+ (
+dœ
+, 
+my´iv
+);
+
+307 
+	`as£¹
+ (!
+”r
+);
+
+309  
+”r
+;
+
+310 
+	}
+}
+
+312 
+”rÜ_t
+
+
+313 
+	$¡ow_š™
+ ()
+
+315 
+”rÜ_t
+ 
+”r
+ = 0;
+
+317 
+¡ow_pÜt_buck‘
+ = 
+	`pÜts_ü—‹_buck‘
+ ();
+
+318 ià(!
+¡ow_pÜt_buck‘
+)
+
+319  
+Ӽo
+;
+
+321 
+¡ow_pÜt_þass
+ = 
+	`pÜts_ü—‹_þass
+ (
+NULL
+, NULL);
+
+322 ià(!
+¡ow_pÜt_þass
+)
+
+323  
+Ӽo
+;
+
+325 
+	`ùh»ad_d‘ach
+ (
+	`ùh»ad_fÜk
+ ( (
+ùh»ad_â_t
+)
+_¡ow_nÙify_th»ad
+, 0));
+
+327  
+”r
+;
+
+328 
+	}
+}
+
+	@stow.h
+
+22 #iâdeà
+_STOW_H
+
+
+23 

+	#_STOW_H
+
+
+	)
+
+25 
+	~"·‰”n.h
+"
+
+27 
+”rÜ_t
+ 
+¡ow_š™
+ ();
+
+28 
+”rÜ_t
+ 
+¡ow_dœadd
+ (*, , 
+·‰”Æi¡
+ *, );
+
+	@ulfs.c
+
+22 

+	#_GNU_SOURCE
+
+
+	)
+
+24 
+	~<hurd/Ãtfs.h
+>
+
+25 
+	~<¡dlib.h
+>
+
+26 
+	~<”rÜ.h
+>
+
+27 
+	~<¡ršg.h
+>
+
+29 
+	~"uniÚfs.h
+"
+
+30 
+	~<fúŽ.h
+>
+
+32 
+	~"lib.h
+"
+
+33 
+	~"ulfs.h
+"
+
+36 
+ulfs_t
+ *
+	gulfs_chaš_¡¬t
+;
+
+40 
+ulfs_t
+ *
+	gulfs_chaš_’d
+;
+
+43 
+	gulfs_num
+;
+
+46 
+mu‹x
+ 
+	gulfs_lock
+ = 
+MUTEX_INITIALIZER
+;
+
+49 
+”rÜ_t
+
+
+50 
+	$ulfs_ü—‹
+ (*
+·th
+, 
+ulfs_t
+ **
+ulfs
+)
+
+52 
+ulfs_t
+ *
+ulfs_Ãw
+ = 
+	`m®loc
+ ( (ulfs_t));
+
+53 
+”rÜ_t
+ 
+”r
+ = 0;
+
+55 ià(! 
+ulfs_Ãw
+)
+
+56 
+”r
+ = 
+ENOMEM
+;
+
+59 *
+·th_ý
+ = 
+·th
+ ? 
+	`¡rdup
+ (·thè: 
+NULL
+;
+
+61 ià(
+·th
+ && (! 
+·th_ý
+))
+
+63 
+”r
+ = 
+ENOMEM
+;
+
+64 
+	`ä“
+ (
+ulfs_Ãw
+);
+
+68 
+ulfs_Ãw
+->
+·th
+ = 
+·th_ý
+;
+
+69 
+ulfs_Ãw
+->
+æags
+ = 0;
+
+70 
+ulfs_Ãw
+->
+Ãxt
+ = 
+NULL
+;
+
+71 
+ulfs_Ãw
+->
+´ev
+ = 
+NULL
+;
+
+72 *
+ulfs
+ = 
+ulfs_Ãw
+;
+
+75  
+”r
+;
+
+76 
+	}
+}
+
+80 
+	$ulfs_de¡roy
+ (
+ulfs_t
+ *
+ulfs
+)
+
+82 
+	`ä“
+ (
+ulfs
+->
+·th
+);
+
+83 
+	`ä“
+ (
+ulfs
+);
+
+84 
+	}
+}
+
+89 
+	$ulfs_š¡®l
+ (
+ulfs_t
+ *
+ulfs
+)
+
+91 
+ulfs_t
+ *
+u
+ = 
+ulfs_chaš_¡¬t
+;
+
+92 
+š£¹_©_’d
+ = 0;
+
+93 ià(
+ulfs_num
+ == 0)
+
+95 
+ulfs_chaš_¡¬t
+ = 
+ulfs
+;
+
+100 
+u
+->
+´iÜ™y
+ > 
+ulfs
+->priority)
+
+102 ià(
+u
+->
+Ãxt
+ =ð
+NULL
+)
+
+104 
+š£¹_©_’d
+ = 1;
+
+107 
+u
+ = u->
+Ãxt
+;
+
+110 ià(
+š£¹_©_’d
+)
+
+112 
+u
+->
+Ãxt
+ = 
+ulfs
+;
+
+113 
+ulfs
+->
+´ev
+ = 
+u
+;
+
+117 ià(
+u
+ =ð
+ulfs_chaš_¡¬t
+)
+
+119 
+ulfs_chaš_¡¬t
+ = 
+ulfs
+;
+
+120 
+ulfs
+->
+Ãxt
+ = 
+u
+;
+
+121 
+ulfs
+->
+´ev
+ = 
+NULL
+;
+
+122 
+u
+->
+´ev
+ = 
+ulfs
+;
+
+126 
+ulfs
+->
+Ãxt
+ = 
+u
+;
+
+127 
+ulfs
+->
+´ev
+ = 
+u
+->prev;
+
+128 
+u
+->
+´ev
+->
+Ãxt
+ = 
+ulfs
+;
+
+129 
+u
+->
+´ev
+ = 
+ulfs
+;
+
+134 
+	}
+}
+
+138 
+	$ulfs_unš¡®l
+ (
+ulfs_t
+ *
+ulfs
+)
+
+140 ià(
+ulfs
+ =ð
+ulfs_chaš_¡¬t
+)
+
+141 
+ulfs_chaš_¡¬t
+ = 
+ulfs
+->
+Ãxt
+;
+
+143 ià(
+ulfs
+->
+Ãxt
+)
+
+144 
+ulfs
+->
+Ãxt
+->
+´ev
+ = ulfs->prev;
+
+146 ià(
+ulfs
+->
+´ev
+)
+
+147 
+ulfs
+->
+´ev
+->
+Ãxt
+ = ulfs->next;
+
+148 
+	}
+}
+
+151 
+”rÜ_t
+
+
+152 
+	$ulfs_g‘_num
+ (
+num
+, 
+ulfs_t
+ **
+ulfs
+)
+
+154 
+”rÜ_t
+ 
+”r
+ = 
+EINVAL
+;
+
+155 
+ulfs_t
+ *
+u
+;
+
+156 
+i
+;
+
+158 
+u
+ = 
+ulfs_chaš_¡¬t
+, 
+i
+ = 0;
+
+159 
+u
+ && 
+i
+ < 
+num
+;
+
+160 
+u
+ = u->
+Ãxt
+, 
+i
+++);
+
+161 ià(
+u
+)
+
+163 
+”r
+ = 0;
+
+164 *
+ulfs
+ = 
+u
+;
+
+167  
+”r
+;
+
+168 
+	}
+}
+
+171 
+”rÜ_t
+
+
+172 
+	$ulfs_g‘_·th
+ (*
+·th
+, 
+ulfs_t
+ **
+ulfs
+)
+
+174 
+”rÜ_t
+ 
+”r
+ = 
+ENOENT
+;
+
+175 
+ulfs_t
+ *
+u
+;
+
+177 
+u
+ = 
+ulfs_chaš_¡¬t
+;
+
+178 
+u
+ && (! (((! 
+·th
+) &&…ath == u->path)
+
+179 || (
+·th
+ && 
+u
+->·th && (! 
+	`¡rcmp
+ (path, u->path)))));
+
+180 
+u
+ = u->
+Ãxt
+);
+
+181 ià(
+u
+)
+
+183 
+”r
+ = 0;
+
+184 *
+ulfs
+ = 
+u
+;
+
+186  
+”r
+;
+
+187 
+	}
+}
+
+189 
+”rÜ_t
+
+
+190 
+ulfs_fÜ_—ch_und”_´iv
+ (*
+·th_und”
+,
+
+191 
+	$”rÜ_t
+ (*
+func
+) (*, *, *),
+
+192 *
+´iv
+)
+
+194 
+”rÜ_t
+ 
+”r
+ = 0;
+
+195 
+ulfs_t
+ *
+u
+;
+
+196 
+size_t
+ 
+Ëngth
+;
+
+198 
+Ëngth
+ = 
+	`¡¾’
+ (
+·th_und”
+);
+
+200 
+u
+ = 
+ulfs_chaš_¡¬t
+; u; u = u->
+Ãxt
+)
+
+202 ià(!
+u
+->
+·th
+)
+
+205 ià(
+	`memcmp
+ (
+u
+->
+·th
+, 
+·th_und”
+, 
+Ëngth
+))
+
+209 
+	`func
+ ((*)(
+u
+->
+·th
+ + 
+Ëngth
+), 
+·th_und”
+, 
+´iv
+);
+
+212  
+”r
+;
+
+213 
+	}
+}
+
+216 
+”rÜ_t
+
+
+217 
+	$ulfs_»gi¡”
+ (*
+·th
+, 
+æags
+, 
+´iÜ™y
+)
+
+219 
+ulfs_t
+ *
+ulfs
+;
+
+220 
+”rÜ_t
+ 
+”r
+;
+
+222 ià(
+·th
+)
+
+224 
+”r
+ = 
+	`check_dœ
+ (
+·th
+);
+
+225 ià(
+”r
+)
+
+226  
+”r
+;
+
+229 
+	`mu‹x_lock
+ (&
+ulfs_lock
+);
+
+230 
+”r
+ = 
+	`ulfs_ü—‹
+ (
+·th
+, &
+ulfs
+);
+
+231 ià(! 
+”r
+)
+
+233 
+ulfs
+->
+æags
+ = flags;
+
+234 
+ulfs
+->
+´iÜ™y
+ =…riority;
+
+235 
+	`ulfs_š¡®l
+ (
+ulfs
+);
+
+236 
+ulfs_num
+++;
+
+238 
+	`mu‹x_uÆock
+ (&
+ulfs_lock
+);
+
+239  
+”r
+;
+
+240 
+	}
+}
+
+245 
+	$ulfs_check
+ ()
+
+247 
+ulfs_t
+ *
+u
+;
+
+248 
+fže_t
+ 
+p
+;
+
+250 
+	sulfs_de¡roy
+
+
+252 
+ulfs_t
+ *
+ulfs
+;
+
+254 
+ulfs_de¡roy
+ *
+Ãxt
+;
+
+255 } *
+ulfs_de¡roy_q
+ = 
+NULL
+;
+
+257 
+	`mu‹x_lock
+ (&
+ulfs_lock
+);
+
+259 
+u
+ = 
+ulfs_chaš_¡¬t
+;
+
+260 
+u
+)
+
+263 ià(
+u
+->
+·th
+)
+
+264 
+p
+ = 
+	`fže_Çme_lookup
+ (
+u
+->
+·th
+, 
+O_READ
+ | 
+O_DIRECTORY
+, 0);
+
+266 
+p
+ = 
+und”lyšg_node
+;
+
+268 ià(! 
+	`pÜt_v®id
+ (
+p
+))
+
+270 
+ulfs_de¡roy
+ *
+±r
+;
+
+273 
+±r
+ = 
+	`m®loc
+ ( (
+ulfs_de¡roy
+));
+
+274 
+	`as£¹
+ (
+±r
+);
+
+276 
+±r
+->
+ulfs
+ = 
+u
+;
+
+278 
+±r
+->
+Ãxt
+ = 
+ulfs_de¡roy_q
+;
+
+279 
+ulfs_de¡roy_q
+ = 
+±r
+;
+
+282 
+u
+ = u->
+Ãxt
+;
+
+285 
+ulfs_de¡roy_q
+)
+
+287 
+ulfs_de¡roy
+ *
+±r
+;
+
+289 
+±r
+ = 
+ulfs_de¡roy_q
+;
+
+290 
+ulfs_de¡roy_q
+ = 
+±r
+->
+Ãxt
+;
+
+292 
+	`ulfs_unš¡®l
+ (
+±r
+->
+ulfs
+);
+
+293 
+	`ulfs_de¡roy
+ (
+±r
+->
+ulfs
+);
+
+294 
+ulfs_num
+--;
+
+296 
+	`ä“
+ (
+±r
+);
+
+299 
+	`mu‹x_uÆock
+ (&
+ulfs_lock
+);
+
+301 
+	}
+}
+
+304 
+”rÜ_t
+
+
+305 
+	$ulfs_uÄegi¡”
+ (*
+·th
+)
+
+307 
+ulfs_t
+ *
+ulfs
+;
+
+308 
+”rÜ_t
+ 
+”r
+;
+
+310 
+	`mu‹x_lock
+ (&
+ulfs_lock
+);
+
+311 
+”r
+ = 
+	`ulfs_g‘_·th
+ (
+·th
+, &
+ulfs
+);
+
+312 ià(! 
+”r
+)
+
+314 
+	`ulfs_unš¡®l
+ (
+ulfs
+);
+
+315 
+	`ulfs_de¡roy
+ (
+ulfs
+);
+
+316 
+ulfs_num
+--;
+
+318 
+	`mu‹x_uÆock
+ (&
+ulfs_lock
+);
+
+320  
+”r
+;
+
+321 
+	}
+}
+
+	@ulfs.h
+
+22 #iâdeà
+INCLUDED_ULFS_H
+
+
+23 

+	#INCLUDED_ULFS_H
+
+
+	)
+
+26 
+	sulfs
+
+
+28 *
+	m·th
+;
+
+29 
+	mæags
+;
+
+30 
+	m´iÜ™y
+;
+
+31 
+ulfs
+ *
+	mÃxt
+, *
+	m´ev
+;
+
+32 } 
+	tulfs_t
+;
+
+37 

+	#FLAG_ULFS_WRITABLE
+ 0x00000001
+
+	)
+
+40 

+ulfs_t
+ *
+ulfs_chaš_¡¬t
+;
+
+44 

+ulfs_t
+ *
+ulfs_chaš_’d
+;
+
+47 

+ulfs_num
+;
+
+50 

+mu‹x
+ 
+ulfs_lock
+;
+
+53 
+”rÜ_t
+ 
+ulfs_»gi¡”
+ (*
+·th
+, 
+æags
+, 
+´iÜ™y
+);
+
+56 
+”rÜ_t
+ 
+ulfs_uÄegi¡”
+ (*
+·th
+);
+
+59 
+”rÜ_t
+ 
+ulfs_g‘_num
+ (
+num
+, 
+ulfs_t
+ **
+ulfs
+);
+
+62 
+ulfs_check
+ ();
+
+64 

+	#ulfs_™”©e
+ \
+
+65 
+ulfs_t
+ *
+ulfs
+ = (
+	`mu‹x_lock
+ (&
+ulfs_lock
+), \
+
+66 
+ulfs_chaš_¡¬t
+); \
+
+67 
+ulfs
+ || (
+	`mu‹x_uÆock
+ (&
+ulfs_lock
+), 0); \
+
+68 
+ulfs
+ = ulfs->
+Ãxt
+)
+
+	)
+
+70 

+	#ulfs_™”©e_uÆocked
+ \
+
+71 
+ulfs_t
+ *
+ulfs
+ = 
+ulfs_chaš_¡¬t
+; \
+
+72 
+ulfs
+; \
+
+73 
+ulfs
+ = ulfs->
+Ãxt
+)
+
+	)
+
+	@unionfs.h
+
+44 #iâdeà
+INCLUDED_UNIONFS_H
+
+
+45 

+	#INCLUDED_UNIONFS_H
+
+
+	)
+
+47 
+	~<hurd/Ãtfs.h
+>
+
+48 
+	~<sys/ty³s.h
+>
+
+50 
+	~"node.h
+"
+
+51 
+	~"lib.h
+"
+
+54 

+	#NCACHE_SIZE
+ 256
+
+	)
+
+57 

+	#UNIONFS_ROOT_INODE
+ 1
+
+	)
+
+62 

+	#FLAG_UNIONFS_MODE_DEBUG
+ 0x00000001
+
+	)
+
+64 

+	#FLAG_UNIONFS_MODE_COW
+ 0x00000002
+
+	)
+
+67 

+uniÚfs_æags
+;
+
+70 

+pid_t
+ 
+fsid
+;
+
+73 
vÞ©ž�
+m­³d_time_v®ue
+ *
+m­time
+;
+
+76 

+mach_pÜt_t
+ 
+und”lyšg_node
+;
+
+79 

+¡©
+ 
+und”lyšg_node_¡©
+;
+
+82 

+	#debug_msg
+(
+fmt
+, 
+¬gs
+...) \
+
+85 ià(
+uniÚfs_æags
+ & 
+FLAG_UNIONFS_MODE_DEBUG
+) \
+
+86 
+	`debug_msg_£nd
+ (
+fmt
+ , ## 
+¬gs
+); \
+
+88 0)
+
+	)
+
+	@update.c
+
+23 

+	#_GNU_SOURCE
+
+
+	)
+
+25 
+	~<Ӽo.h
+>
+
+26 
+	~<¡ršg.h
+>
+
+27 
+	~<ùh»ads.h
+>
+
+28 
+	~<rwlock.h
+>
+
+30 
+	~"nÿche.h
+"
+
+31 
+	~"node.h
+"
+
+32 
+	~"ulfs.h
+"
+
+37 
+rwlock
+ 
+	gupd©e_rwlock
+;
+
+38 
+cÚd™iÚ
+ 
+	gupd©e_wakeup
+;
+
+39 
+mu‹x
+ 
+	gupd©e_lock
+;
+
+42 
+	$_roÙ_upd©e_th»ad
+ ()
+
+44 
+”rÜ_t
+ 
+”r
+;
+
+48 ià(
+	`hurd_cÚd™iÚ_wa™
+ (&
+upd©e_wakeup
+, &
+upd©e_lock
+))
+
+49 
+	`mu‹x_uÆock
+ (&
+upd©e_lock
+);
+
+51 
+	`rwlock_wr™”_lock
+ (&
+upd©e_rwlock
+);
+
+55 
+	`ulfs_check
+();
+
+56 
+”r
+ = 
+	`node_š™_roÙ
+ (
+Ãtfs_roÙ_node
+);
+
+58 
+”r
+ =ð
+ENOENT
+);
+
+60 ià(
+”r
+)
+
+62 
+	`årštf
+ (
+¡d”r
+, "upd©�th»ad: gÙ‡ %s\n", 
+	`¡»¼Ü
+ (
+”r
+));
+
+65 
+	`nÿche_»£t
+ ();
+
+67 
+	`rwlock_wr™”_uÆock
+ (&
+upd©e_rwlock
+);
+
+69 
+	}
+}
+
+72 
+	$roÙ_upd©e_scheduË
+ ()
+
+74 
+	`cÚd™iÚ_sigÇl
+ (&
+upd©e_wakeup
+);
+
+75 
+	}
+}
+
+78 
+	$roÙ_upd©e_di§bË
+ ()
+
+80 
+	`rwlock_»ad”_lock
+ (&
+upd©e_rwlock
+);
+
+81 
+	}
+}
+
+84 
+	$roÙ_upd©e_’abË
+ ()
+
+86 
+	`rwlock_»ad”_uÆock
+ (&
+upd©e_rwlock
+);
+
+87 
+	}
+}
+
+90 
+	$roÙ_upd©e_š™
+()
+
+92 
+	`mu‹x_š™
+ (&
+upd©e_lock
+);
+
+93 
+	`rwlock_š™
+ (&
+upd©e_rwlock
+);
+
+94 
+	`cÚd™iÚ_š™
+ (&
+upd©e_wakeup
+);
+
+96 
+	`ùh»ad_d‘ach
+ (
+	`ùh»ad_fÜk
+ ( (
+ùh»ad_â_t
+)
+_roÙ_upd©e_th»ad
+, 0));
+
+97 
+	}
+}
+
+	@update.h
+
+20 #iâdeà
+_UDPATE_H
+
+
+21 

+	#_UPDATE_H
+
+
+	)
+
+23 
+roÙ_upd©e_scheduË
+ ();
+
+24 
+roÙ_upd©e_di§bË
+ ();
+
+25 
+roÙ_upd©e_’abË
+ ();
+
+26 
+roÙ_upd©e_š™
+ ();
+
+	@version.h
+
+21 #iâdeà
+HURD_VERSION
+
+
+22 

+	#HURD_VERSION
+ "0.3"
+
+	)
+
+26 

+	#STANDARD_HURD_VERSION
+(
+s
+) \
+
+27 # " (GNU Hurdè" 
+HURD_VERSION
+
+
+	)
+
+28 

+	#STANDARD_HURD_VERSION_EXTRA
+(
+s
+, 
+exŒa
+) \
+
+29 # " (GNU Hurd; " 
+exŒa
+ "è" 
+HURD_VERSION
+
+
+	)
+
+	@/usr/include/assert.h
+
+42 
+	~<sys/cdefs.h
+>
+
+43 #ifdeà
+__ýlu¥lus
+
+
+44 
+	~<¡dlib.h
+>
+
+52 #undeà
+as£¹
+
+
+53 #undeà
+__as£¹
+
+
+55 #ifdeà
+NDEBUG
+
+
+56 

+	#as£¹
+(
+e
+è(()0)
+
+	)
+
+59 #iâdeà
+__GNUC__
+
+
+61 
+	g__BEGIN_DECLS
+
+
+62 #iâdeà
+__ýlu¥lus
+
+
+63 
+	$abÜt
+(è
+__d—d2
+;
+
+65 
+	`´štf
+(cÚ¡ * 
+__»¡riù
+, ...);
+
+66 
+__END_DECLS
+
+
+68 

+	#as£¹
+(
+e
+) \
+
+69 ((è((
+e
+è? 0 : 
+	`__as£¹
+ (#e, 
+__FILE__
+, 
+__LINE__
+)))
+
+	)
+
+70 

+	#__as£¹
+(
+e
+, 
+fže
+, 
+lše
+) \
+
+71 (()
+	`´štf
+ ("%s:%u: fažed‡s£¹iÚ `%s'\n", 
+fže
+, 
+lše
+, 
+e
+), 
+	`abÜt
+())
+
+	)
+
+75 
+__BEGIN_DECLS
+
+
+76 
+	$__as£¹_¹n
+(cÚ¡ *, cÚ¡ *, , cÚ¡ *è
+__d—d2
+;
+
+77 
+	$__•rštf
+(cÚ¡ *, cÚ¡ *, , cÚ¡ *è
+__d—d2
+;
+
+78 
+__END_DECLS
+
+
+80 

+	#__as£¹
+(
+e
+, 
+fže
+, 
+lše
+) \
+
+81 
+	`__•rštf
+ ("%s:%u: fažed‡s£¹iÚ `%s'\n", 
+fže
+, 
+lše
+, 
+e
+)
+
+	)
+
+83 #ià
+__DARWIN_UNIX03
+
+
+84 

+	#as£¹
+(
+e
+) \
+
+85 (
+	`__bužtš_ex³ù
+(!(
+e
+), 0è? 
+	`__as£¹_¹n
+(
+__func__
+, 
+__FILE__
+, 
+__LINE__
+, #eè: ()0)
+
+	)
+
+87 

+	#as£¹
+(
+e
+) \
+
+88 (
+	`__bužtš_ex³ù
+(!(
+e
+), 0è? 
+	`__as£¹
+ (#e, 
+__FILE__
+, 
+__LINE__
+è: ()0)
+
+	)
+
+	@/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/errno.h
+
+23 
+	~<sys/Ӽo.h
+>
+
+	@/usr/include/fcntl.h
+
+23 
+	~<sys/fúŽ.h
+>
+
+	@/usr/include/fnmatch.h
+
+58 #iâdef 
+_FNMATCH_H_
+
+
+59 

+	#_FNMATCH_H_
+
+
+	)
+
+61 
+	~<sys/cdefs.h
+>
+
+63 

+	#FNM_NOMATCH
+ 1
+
+	)
+
+65 

+	#FNM_NOESCAPE
+ 0x01
+
+	)
+
+66 

+	#FNM_PATHNAME
+ 0x02
+
+	)
+
+67 

+	#FNM_PERIOD
+ 0x04
+
+	)
+
+69 

+	#FNM_NOSYS
+ (-1è
+
+	)
+
+71 #ià!
+defšed
+(
+_ANSI_SOURCE
+è&& (!defšed(
+_POSIX_C_SOURCE
+è|| defšed(
+_DARWIN_C_SOURCE
+))
+
+72 

+	#FNM_LEADING_DIR
+ 0x08
+
+	)
+
+73 

+	#FNM_CASEFOLD
+ 0x10
+
+	)
+
+74 

+	#FNM_IGNORECASE
+ 
+FNM_CASEFOLD
+
+
+	)
+
+75 

+	#FNM_FILE_NAME
+ 
+FNM_PATHNAME
+
+
+	)
+
+78 
+__BEGIN_DECLS
+
+
+79 
+	$âm©ch
+(cÚ¡ *, cÚ¡ *, è
+	`__DARWIN_ALIAS
+(
+âm©ch
+);
+
+80 
+__END_DECLS
+
+
+	@/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/string.h
+
+58 #iâdeà
+_STRING_H_
+
+
+59 

+	#_STRING_H_
+
+
+	)
+
+60 
+	~<_ty³s.h
+>
+
+62 #iâdef 
+_SIZE_T
+
+
+63 

+	#_SIZE_T
+
+
+	)
+
+64 
+__d¬wš_size_t
+ 
+	tsize_t
+;
+
+67 #ià!
+defšed
+(
+_POSIX_C_SOURCE
+è|| defšed(
+_DARWIN_C_SOURCE
+)
+
+68 #iâdeà
+_SSIZE_T
+
+
+69 

+	#_SSIZE_T
+
+
+	)
+
+70 
+__d¬wš_ssize_t
+ 
+	tssize_t
+;
+
+74 #iâdeà
+NULL
+
+
+75 

+	#NULL
+ 
+__DARWIN_NULL
+
+
+	)
+
+78 
+	~<sys/cdefs.h
+>
+
+80 
+__BEGIN_DECLS
+
+
+81 *
+memchr
+(cÚ¡ *, , 
+size_t
+);
+
+82 
+memcmp
+(cÚ¡ *, cÚ¡ *, 
+size_t
+);
+
+83 *
+memýy
+(*, cÚ¡ *, 
+size_t
+);
+
+84 *
+memmove
+(*, cÚ¡ *, 
+size_t
+);
+
+85 *
+mem£t
+(*, , 
+size_t
+);
+
+86 #ià!
+defšed
+(
+_POSIX_C_SOURCE
+è|| defšed(
+_DARWIN_C_SOURCE
+)
+
+87 *
+¡pýy
+(*, const *);
+
+88 *
+¡rÿ£¡r
+(const *, const *);
+
+90 *
+¡rÿt
+(*, const *);
+
+91 *
+¡rchr
+(const *, );
+
+92 
+¡rcmp
+(const *, const *);
+
+93 
+¡rcÞl
+(const *, const *);
+
+94 *
+¡rýy
+(*, const *);
+
+95 
+size_t
+ 
+¡rc¥n
+(const *, const *);
+
+96 *
+	$¡»¼Ü
+(è
+	`__DARWIN_ALIAS
+(
+¡»¼Ü
+);
+
+97 
+	`¡»¼Ü_r
+(, *, 
+size_t
+);
+
+98 
+size_t
+ 
+	`¡¾’
+(const *);
+
+99 *
+	`¡ºÿt
+(*, cÚ¡ *, 
+size_t
+);
+
+100 
+	`¡ºcmp
+(cÚ¡ *, cÚ¡ *, 
+size_t
+);
+
+101 *
+	`¡ºýy
+(*, cÚ¡ *, 
+size_t
+);
+
+102 #ià!
+	`defšed
+(
+_POSIX_C_SOURCE
+è|| defšed(
+_DARWIN_C_SOURCE
+)
+
+103 *
+	`¡º¡r
+(cÚ¡ *, cÚ¡ *, 
+size_t
+);
+
+105 *
+	`¡½brk
+(const *, const *);
+
+106 *
+	`¡¼chr
+(const *, );
+
+107 
+size_t
+ 
+	`¡r¥n
+(const *, const *);
+
+108 *
+	`¡r¡r
+(const *, const *);
+
+109 *
+	`¡¹ok
+(*, const *);
+
+110 
+size_t
+ 
+	`¡rxäm
+(*, const *, size_t);
+
+113 #iâdeà
+_ANSI_SOURCE
+
+
+114 *
+	`memcýy
+(*, cÚ¡ *, , 
+size_t
+);
+
+115 *
+	`¡¹ok_r
+(*, const *, **);
+
+116 *
+	`¡rdup
+(const *);
+
+117 #ià!
+	`defšed
+(
+_POSIX_C_SOURCE
+è|| defšed(
+_DARWIN_C_SOURCE
+)
+
+118 
+	`bcmp
+(cÚ¡ *, cÚ¡ *, 
+size_t
+);
+
+119 
+	`bcÝy
+(cÚ¡ *, *, 
+size_t
+);
+
+120 
+	`bz”o
+(*, 
+size_t
+);
+
+121 
+	`ffs
+();
+
+122 
+	`ff¦
+();
+
+123 
+	`æs
+();
+
+124 
+	`æ¦
+();
+
+125 *
+	`šdex
+(const *, );
+
+126 
+	`mem£t_·‰”n4
+(*, cÚ¡ *, 
+size_t
+);
+
+127 
+	`mem£t_·‰”n8
+(*, cÚ¡ *, 
+size_t
+);
+
+128 
+	`mem£t_·‰”n16
+(*, cÚ¡ *, 
+size_t
+);
+
+129 *
+	`ršdex
+(const *, );
+
+130 
+	`¡rÿ£cmp
+(const *, const *);
+
+131 
+size_t
+ 
+	`¡¾ÿt
+(*, const *, size_t);
+
+132 
+size_t
+ 
+	`¡¾ýy
+(*, const *, size_t);
+
+133 
+	`¡rmode
+(, *);
+
+134 
+	`¡ºÿ£cmp
+(cÚ¡ *, cÚ¡ *, 
+size_t
+);
+
+135 *
+	`¡r£p
+(**, const *);
+
+136 *
+	`¡rsigÇl
+(
+sig
+);
+
+137 
+	`swab
+(cÚ¡ * 
+__»¡riù
+, * __»¡riù, 
+ssize_t
+);
+
+140 
+__END_DECLS
+
+
+142 #ifdeà
+_USE_EXTENDED_LOCALES_
+
+
+143 
+	~<xloÿË/_¡ršg.h
+>
+
+146 #ià
+	`defšed
+ (
+__GNUC__
+è&& 
+_FORTIFY_SOURCE
+ > 0 && !defšed (
+__ýlu¥lus
+)
+
+148 
+	~<£cu»/_¡ršg.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/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/secure/_string.h
+
+24 #iâdeà
+_STRING_H_
+
+
+28 #iâdeà
+_SECURE__STRING_H_
+
+
+29 

+	#_SECURE__STRING_H_
+
+
+	)
+
+31 
+	~<£cu»/_commÚ.h
+>
+
+33 #ià
+_USE_FORTIFY_LEVEL
+ > 0
+
+38 #undeà
+memýy
+
+
+39 #undeà
+memmove
+
+
+40 #undeà
+mem£t
+
+
+41 #undeà
+¡rýy
+
+
+42 #undeà
+¡pýy
+
+
+43 #undeà
+¡ºýy
+
+
+44 #undeà
+¡rÿt
+
+
+45 #undeà
+¡ºÿt
+
+
+47 

+	#memýy
+(
+de¡
+, 
+¤c
+, 
+Ën
+) \
+
+48 ((
+	`__d¬wš_obsz0
+ (
+de¡
+è!ð(
+size_t
+) -1) \
+
+49 ? 
+	`__bužtš___memýy_chk
+ (
+de¡
+, 
+¤c
+, 
+Ën
+, 
+	`__d¬wš_obsz0
+ (dest)) \
+
+50 : 
+	`__šlše_memýy_chk
+ (
+de¡
+, 
+¤c
+, 
+Ën
+))
+
+	)
+
+52 
+šlše
+ *
+
+53 
+	$__šlše_memýy_chk
+ (*
+__de¡
+, cÚ¡ *
+__¤c
+, 
+size_t
+ 
+__Ën
+)
+
+55  
+	`__bužtš___memýy_chk
+ (
+__de¡
+, 
+__¤c
+, 
+__Ën
+, 
+	`__d¬wš_obsz0
+(__dest));
+
+56 
+	}
+}
+
+58 

+	#memmove
+(
+de¡
+, 
+¤c
+, 
+Ën
+) \
+
+59 ((
+	`__d¬wš_obsz0
+ (
+de¡
+è!ð(
+size_t
+) -1) \
+
+60 ? 
+	`__bužtš___memmove_chk
+ (
+de¡
+, 
+¤c
+, 
+Ën
+, 
+	`__d¬wš_obsz0
+ (dest)) \
+
+61 : 
+	`__šlše_memmove_chk
+ (
+de¡
+, 
+¤c
+, 
+Ën
+))
+
+	)
+
+63 
+šlše
+ *
+
+64 
+	$__šlše_memmove_chk
+ (*
+__de¡
+, cÚ¡ *
+__¤c
+, 
+size_t
+ 
+__Ën
+)
+
+66  
+	`__bužtš___memmove_chk
+ (
+__de¡
+, 
+__¤c
+, 
+__Ën
+, 
+	`__d¬wš_obsz0
+(__dest));
+
+67 
+	}
+}
+
+69 

+	#mem£t
+(
+de¡
+, 
+v®
+, 
+Ën
+) \
+
+70 ((
+	`__d¬wš_obsz0
+ (
+de¡
+è!ð(
+size_t
+) -1) \
+
+71 ? 
+	`__bužtš___mem£t_chk
+ (
+de¡
+, 
+v®
+, 
+Ën
+, 
+	`__d¬wš_obsz0
+ (dest)) \
+
+72 : 
+	`__šlše_mem£t_chk
+ (
+de¡
+, 
+v®
+, 
+Ën
+))
+
+	)
+
+74 
+šlše
+ *
+
+75 
+	$__šlše_mem£t_chk
+ (*
+__de¡
+, 
+__v®
+, 
+size_t
+ 
+__Ën
+)
+
+77  
+	`__bužtš___mem£t_chk
+ (
+__de¡
+, 
+__v®
+, 
+__Ën
+, 
+	`__d¬wš_obsz0
+(__dest));
+
+78 
+	}
+}
+
+80 

+	#¡rýy
+(
+de¡
+, 
+¤c
+) \
+
+81 ((
+	`__d¬wš_obsz0
+ (
+de¡
+è!ð(
+size_t
+) -1) \
+
+82 ? 
+	`__bužtš___¡rýy_chk
+ (
+de¡
+, 
+¤c
+, 
+	`__d¬wš_obsz
+ (dest)) \
+
+83 : 
+	`__šlše_¡rýy_chk
+ (
+de¡
+, 
+¤c
+))
+
+	)
+
+85 
+šlše
+ *
+
+86 
+	$__šlše_¡rýy_chk
+ (*
+__»¡riù
+ 
+__de¡
+, cÚ¡ *__»¡riù 
+__¤c
+)
+
+88  
+	`__bužtš___¡rýy_chk
+ (
+__de¡
+, 
+__¤c
+, 
+	`__d¬wš_obsz
+(__dest));
+
+89 
+	}
+}
+
+91 

+	#¡pýy
+(
+de¡
+, 
+¤c
+) \
+
+92 ((
+	`__d¬wš_obsz0
+ (
+de¡
+è!ð(
+size_t
+) -1) \
+
+93 ? 
+	`__bužtš___¡pýy_chk
+ (
+de¡
+, 
+¤c
+, 
+	`__d¬wš_obsz
+ (dest)) \
+
+94 : 
+	`__šlše_¡pýy_chk
+ (
+de¡
+, 
+¤c
+))
+
+	)
+
+96 
+šlše
+ *
+
+97 
+	$__šlše_¡pýy_chk
+ (*
+__de¡
+, cÚ¡ *
+__¤c
+)
+
+99  
+	`__bužtš___¡pýy_chk
+ (
+__de¡
+, 
+__¤c
+, 
+	`__d¬wš_obsz
+(__dest));
+
+100 
+	}
+}
+
+102 

+	#¡ºýy
+(
+de¡
+, 
+¤c
+, 
+Ën
+) \
+
+103 ((
+	`__d¬wš_obsz0
+ (
+de¡
+è!ð(
+size_t
+) -1) \
+
+104 ? 
+	`__bužtš___¡ºýy_chk
+ (
+de¡
+, 
+¤c
+, 
+Ën
+, 
+	`__d¬wš_obsz
+ (dest)) \
+
+105 : 
+	`__šlše_¡ºýy_chk
+ (
+de¡
+, 
+¤c
+, 
+Ën
+))
+
+	)
+
+107 
+šlše
+ *
+
+108 
+	$__šlše_¡ºýy_chk
+ (*
+__»¡riù
+ 
+__de¡
+, cÚ¡ *__»¡riù 
+__¤c
+,
+
+109 
+size_t
+ 
+__Ën
+)
+
+111  
+	`__bužtš___¡ºýy_chk
+ (
+__de¡
+, 
+__¤c
+, 
+__Ën
+, 
+	`__d¬wš_obsz
+(__dest));
+
+112 
+	}
+}
+
+114 

+	#¡rÿt
+(
+de¡
+, 
+¤c
+) \
+
+115 ((
+	`__d¬wš_obsz0
+ (
+de¡
+è!ð(
+size_t
+) -1) \
+
+116 ? 
+	`__bužtš___¡rÿt_chk
+ (
+de¡
+, 
+¤c
+, 
+	`__d¬wš_obsz
+ (dest)) \
+
+117 : 
+	`__šlše_¡rÿt_chk
+ (
+de¡
+, 
+¤c
+))
+
+	)
+
+119 
+šlše
+ *
+
+120 
+	$__šlše_¡rÿt_chk
+ (*
+__»¡riù
+ 
+__de¡
+, cÚ¡ *__»¡riù 
+__¤c
+)
+
+122  
+	`__bužtš___¡rÿt_chk
+ (
+__de¡
+, 
+__¤c
+, 
+	`__d¬wš_obsz
+(__dest));
+
+123 
+	}
+}
+
+125 

+	#¡ºÿt
+(
+de¡
+, 
+¤c
+, 
+Ën
+) \
+
+126 ((
+	`__d¬wš_obsz0
+ (
+de¡
+è!ð(
+size_t
+) -1) \
+
+127 ? 
+	`__bužtš___¡rÿt_chk
+ (
+de¡
+, 
+¤c
+, 
+	`__d¬wš_obsz
+ (dest)) \
+
+128 : 
+	`__šlše_¡ºÿt_chk
+ (
+de¡
+, 
+¤c
+, 
+Ën
+))
+
+	)
+
+130 
+šlše
+ *
+
+131 
+	$__šlše_¡ºÿt_chk
+ (*
+__»¡riù
+ 
+__de¡
+, cÚ¡ *__»¡riù 
+__¤c
+,
+
+132 
+size_t
+ 
+__Ën
+)
+
+134  
+	`__bužtš___¡ºÿt_chk
+ (
+__de¡
+, 
+__¤c
+, 
+__Ën
+, 
+	`__d¬wš_obsz
+(__dest));
+
+135 
+	}
+}
+
+	@/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/errno.h
+
+69 #iâdef 
+_SYS_ERRNO_H_
+
+
+70 

+	#_SYS_ERRNO_H_
+
+
+	)
+
+72 
+	~<sys/cdefs.h
+>
+
+73 
+__BEGIN_DECLS
+
+
+74 
* 
+__”rÜ
+();
+
+75 

+	#Ӽo
+ (*
+	`__”rÜ
+())
+
+	)
+
+76 
+	g__END_DECLS
+
+
+82 

+	#EPERM
+ 1
+
+	)
+
+83 

+	#ENOENT
+ 2
+
+	)
+
+84 

+	#ESRCH
+ 3
+
+	)
+
+85 

+	#EINTR
+ 4
+
+	)
+
+86 

+	#EIO
+ 5
+
+	)
+
+87 

+	#ENXIO
+ 6
+
+	)
+
+88 

+	#E2BIG
+ 7
+
+	)
+
+89 

+	#ENOEXEC
+ 8
+
+	)
+
+90 

+	#EBADF
+ 9
+
+	)
+
+91 

+	#ECHILD
+ 10
+
+	)
+
+92 

+	#EDEADLK
+ 11
+
+	)
+
+94 

+	#ENOMEM
+ 12
+
+	)
+
+95 

+	#EACCES
+ 13
+
+	)
+
+96 

+	#EFAULT
+ 14
+
+	)
+
+97 #ià!
+defšed
+(
+_POSIX_C_SOURCE
+è|| defšed(
+_DARWIN_C_SOURCE
+)
+
+98 

+	#ENOTBLK
+ 15
+
+	)
+
+100 

+	#EBUSY
+ 16
+
+	)
+
+101 

+	#EEXIST
+ 17
+
+	)
+
+102 

+	#EXDEV
+ 18
+
+	)
+
+103 

+	#ENODEV
+ 19
+
+	)
+
+104 

+	#ENOTDIR
+ 20
+
+	)
+
+105 

+	#EISDIR
+ 21
+
+	)
+
+106 

+	#EINVAL
+ 22
+
+	)
+
+107 

+	#ENFILE
+ 23
+
+	)
+
+108 

+	#EMFILE
+ 24
+
+	)
+
+109 

+	#ENOTTY
+ 25
+
+	)
+
+110 

+	#ETXTBSY
+ 26
+
+	)
+
+111 

+	#EFBIG
+ 27
+
+	)
+
+112 

+	#ENOSPC
+ 28
+
+	)
+
+113 

+	#ESPIPE
+ 29
+
+	)
+
+114 

+	#EROFS
+ 30
+
+	)
+
+115 

+	#EMLINK
+ 31
+
+	)
+
+116 

+	#EPIPE
+ 32
+
+	)
+
+119 

+	#EDOM
+ 33
+
+	)
+
+120 

+	#ERANGE
+ 34
+
+	)
+
+123 

+	#EAGAIN
+ 35
+
+	)
+
+124 

+	#EWOULDBLOCK
+ 
+EAGAIN
+
+
+	)
+
+125 

+	#EINPROGRESS
+ 36
+
+	)
+
+126 

+	#EALREADY
+ 37
+
+	)
+
+129 

+	#ENOTSOCK
+ 38
+
+	)
+
+130 

+	#EDESTADDRREQ
+ 39
+
+	)
+
+131 

+	#EMSGSIZE
+ 40
+
+	)
+
+132 

+	#EPROTOTYPE
+ 41
+
+	)
+
+133 

+	#ENOPROTOOPT
+ 42
+
+	)
+
+134 

+	#EPROTONOSUPPORT
+ 43
+
+	)
+
+135 #ià!
+defšed
+(
+_POSIX_C_SOURCE
+è|| defšed(
+_DARWIN_C_SOURCE
+)
+
+136 

+	#ESOCKTNOSUPPORT
+ 44
+
+	)
+
+138 

+	#ENOTSUP
+ 45
+
+	)
+
+139 #ià!
+__DARWIN_UNIX03
+ && !
+defšed
+(
+KERNEL
+)
+
+148 

+	#EOPNOTSUPP
+ 
+ENOTSUP
+
+
+	)
+
+151 #ià!
+defšed
+(
+_POSIX_C_SOURCE
+è|| defšed(
+_DARWIN_C_SOURCE
+)
+
+152 

+	#EPFNOSUPPORT
+ 46
+
+	)
+
+154 

+	#EAFNOSUPPORT
+ 47
+
+	)
+
+155 

+	#EADDRINUSE
+ 48
+
+	)
+
+156 

+	#EADDRNOTAVAIL
+ 49
+
+	)
+
+159 

+	#ENETDOWN
+ 50
+
+	)
+
+160 

+	#ENETUNREACH
+ 51
+
+	)
+
+161 

+	#ENETRESET
+ 52
+
+	)
+
+162 

+	#ECONNABORTED
+ 53
+
+	)
+
+163 

+	#ECONNRESET
+ 54
+
+	)
+
+164 

+	#ENOBUFS
+ 55
+
+	)
+
+165 

+	#EISCONN
+ 56
+
+	)
+
+166 

+	#ENOTCONN
+ 57
+
+	)
+
+167 #ià!
+defšed
+(
+_POSIX_C_SOURCE
+è|| defšed(
+_DARWIN_C_SOURCE
+)
+
+168 

+	#ESHUTDOWN
+ 58
+
+	)
+
+169 

+	#ETOOMANYREFS
+ 59
+
+	)
+
+171 

+	#ETIMEDOUT
+ 60
+
+	)
+
+172 

+	#ECONNREFUSED
+ 61
+
+	)
+
+174 

+	#ELOOP
+ 62
+
+	)
+
+175 

+	#ENAMETOOLONG
+ 63
+
+	)
+
+178 #ià!
+defšed
+(
+_POSIX_C_SOURCE
+è|| defšed(
+_DARWIN_C_SOURCE
+)
+
+179 

+	#EHOSTDOWN
+ 64
+
+	)
+
+181 

+	#EHOSTUNREACH
+ 65
+
+	)
+
+182 

+	#ENOTEMPTY
+ 66
+
+	)
+
+185 #ià!
+defšed
+(
+_POSIX_C_SOURCE
+è|| defšed(
+_DARWIN_C_SOURCE
+)
+
+186 

+	#EPROCLIM
+ 67
+
+	)
+
+187 

+	#EUSERS
+ 68
+
+	)
+
+189 

+	#EDQUOT
+ 69
+
+	)
+
+192 

+	#ESTALE
+ 70
+
+	)
+
+193 #ià!
+defšed
+(
+_POSIX_C_SOURCE
+è|| defšed(
+_DARWIN_C_SOURCE
+)
+
+194 

+	#EREMOTE
+ 71
+
+	)
+
+195 

+	#EBADRPC
+ 72
+
+	)
+
+196 

+	#ERPCMISMATCH
+ 73
+
+	)
+
+197 

+	#EPROGUNAVAIL
+ 74
+
+	)
+
+198 

+	#EPROGMISMATCH
+ 75
+
+	)
+
+199 

+	#EPROCUNAVAIL
+ 76
+
+	)
+
+202 

+	#ENOLCK
+ 77
+
+	)
+
+203 

+	#ENOSYS
+ 78
+
+	)
+
+205 #ià!
+defšed
+(
+_POSIX_C_SOURCE
+è|| defšed(
+_DARWIN_C_SOURCE
+)
+
+206 

+	#EFTYPE
+ 79
+
+	)
+
+207 

+	#EAUTH
+ 80
+
+	)
+
+208 

+	#ENEEDAUTH
+ 81
+
+	)
+
+211 

+	#EPWROFF
+ 82
+
+	)
+
+212 

+	#EDEVERR
+ 83
+
+	)
+
+215 

+	#EOVERFLOW
+ 84
+
+	)
+
+218 #ià!
+defšed
+(
+_POSIX_C_SOURCE
+è|| defšed(
+_DARWIN_C_SOURCE
+)
+
+219 

+	#EBADEXEC
+ 85
+
+	)
+
+220 

+	#EBADARCH
+ 86
+
+	)
+
+221 

+	#ESHLIBVERS
+ 87
+
+	)
+
+222 

+	#EBADMACHO
+ 88
+
+	)
+
+225 

+	#ECANCELED
+ 89
+
+	)
+
+227 

+	#EIDRM
+ 90
+
+	)
+
+228 

+	#ENOMSG
+ 91
+
+	)
+
+229 

+	#EILSEQ
+ 92
+
+	)
+
+230 #ià!
+defšed
+(
+_POSIX_C_SOURCE
+è|| defšed(
+_DARWIN_C_SOURCE
+)
+
+231 

+	#ENOATTR
+ 93
+
+	)
+
+234 

+	#EBADMSG
+ 94
+
+	)
+
+235 

+	#EMULTIHOP
+ 95
+
+	)
+
+236 

+	#ENODATA
+ 96
+
+	)
+
+237 

+	#ENOLINK
+ 97
+
+	)
+
+238 

+	#ENOSR
+ 98
+
+	)
+
+239 

+	#ENOSTR
+ 99
+
+	)
+
+240 

+	#EPROTO
+ 100
+
+	)
+
+241 

+	#ETIME
+ 101
+
+	)
+
+243 #ià
+__DARWIN_UNIX03
+ || 
+defšed
+(
+KERNEL
+)
+
+245 

+	#EOPNOTSUPP
+ 102
+
+	)
+
+248 

+	#ENOPOLICY
+ 103
+
+	)
+
+250 #ià!
+defšed
+(
+_POSIX_C_SOURCE
+è|| defšed(
+_DARWIN_C_SOURCE
+)
+
+251 

+	#ELAST
+ 103
+
+	)
+
+	@/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/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/xlocale/_string.h
+
+24 #iâdeà
+_XLOCALE__STRING_H_
+
+
+25 

+	#_XLOCALE__STRING_H_
+
+
+	)
+
+27 
+__BEGIN_DECLS
+
+
+28 
+¡rcÞl_l
+(cÚ¡ *, cÚ¡ *, 
+loÿË_t
+);
+
+29 
+size_t
+ 
+¡rxäm_l
+(*, cÚ¡ *, size_t, 
+loÿË_t
+);
+
+30 
+¡rÿ£cmp_l
+(cÚ¡ *, cÚ¡ *, 
+loÿË_t
+);
+
+31 *
+¡rÿ£¡r_l
+(cÚ¡ *, cÚ¡ *, 
+loÿË_t
+);
+
+32 
+¡ºÿ£cmp_l
+(cÚ¡ *, cÚ¡ *, 
+size_t
+, 
+loÿË_t
+);
+
+33 
+	g__END_DECLS
+
+
+	@/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/_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/_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/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/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/_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
+80
+1708
+lib.c
+lib.h
+lnode.c
+lnode.h
+main.c
+ncache.c
+ncache.h
+netfs.c
+node.c
+node.h
+options.c
+options.h
+pattern.c
+pattern.h
+stow-mutations.h
+stow-priv.h
+stow.c
+stow.h
+ulfs.c
+ulfs.h
+unionfs.h
+update.c
+update.h
+version.h
+/usr/include/assert.h
+/usr/include/dirent.h
+/usr/include/errno.h
+/usr/include/fcntl.h
+/usr/include/fnmatch.h
+/usr/include/stddef.h
+/usr/include/stdio.h
+/usr/include/stdlib.h
+/usr/include/string.h
+/usr/include/sys/mman.h
+/usr/include/sys/stat.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/secure/_string.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/errno.h
+/usr/include/sys/fcntl.h
+/usr/include/sys/select.h
+/usr/include/sys/unistd.h
+/usr/include/sys/wait.h
+/usr/include/xlocale/_stdio.h
+/usr/include/xlocale/_stdlib.h
+/usr/include/xlocale/_string.h
+/usr/include/i386/endian.h
+/usr/include/i386/types.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/_select.h
+/usr/include/sys/resource.h
+/usr/include/sys/signal.h
+/usr/include/i386/_structs.h
+/usr/include/i386/_types.h
+/usr/include/machine/signal.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/unionfs/lib.c b/unionfs/lib.c
new file mode 100644
index 00000000..0423c1bc
--- /dev/null
+++ b/unionfs/lib.c
@@ -0,0 +1,280 @@
+/* Hurd unionfs
+   Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
+   Written by Moritz Schulte <moritz@duesseldorf.ccc.de>.
+
+   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 <hurd/netfs.h>
+#include <error.h>
+#include <dirent.h>
+#include <errno.h>
+#include <sys/mman.h>
+#include <stddef.h>
+
+#include "lib.h"
+
+/* Lock, which must be held, during printing of debugging
+   messages.  */
+struct mutex debug_msg_lock = MUTEX_INITIALIZER;
+
+/* Returns no error if PATH points to a directory.  */
+error_t check_dir (char *path)
+{
+  struct stat filestat;
+  error_t err = 0;
+
+  err = stat (path, &filestat);
+  if (err)
+    return err;
+
+  if (!S_ISDIR (filestat.st_mode))
+    return ENOTDIR;
+
+  return 0;
+}
+
+/* Fetch directory entries for DIR; store the raw data as returned by
+   the dir_readdir RPC in *DIRENT_DATA, the size of *DIRENT_DATA in
+   *DIRENT_DATA_SIZE and a list of pointers to the dirent structures
+   in *DIRENT_LIST.  */
+error_t
+dir_entries_get (file_t dir, char **dirent_data, 
+		 size_t *dirent_data_size, struct dirent ***dirent_list)
+{
+  error_t err;
+  size_t data_size;
+  int entries_num;
+  char *data;
+
+  err = dir_readdir (dir, &data, &data_size, 0, -1, 0, &entries_num);
+  if (! err)
+    {
+      struct dirent **list;
+  
+      list = malloc (sizeof (struct dirent *) * (entries_num + 1));
+      if (list)
+	{	
+	  struct dirent *dp;
+	  int i;
+
+	  for (i = 0, dp = (struct dirent *) data;
+	       i < entries_num;
+	       i++, dp = (struct dirent *) ((char *) dp + dp->d_reclen))
+	    *(list + i) = dp;
+	  *(list + i) = NULL;
+
+	  *dirent_data = data;
+	  *dirent_data_size = data_size;
+	  *dirent_list = list;
+	}
+      else
+	{
+	  munmap (data, data_size);
+	  err = ENOMEM;
+	}
+    }
+  return err;
+}
+
+/* Lookup the file named NAME beneath DIR (or the cwd, if DIR is not a
+   valid port.  Try to open with FLAGS0 first, and if that fails with
+   FLAGS1; MODE is the mode to user for newly created files.  On
+   success, stat the looked up port and store it in *PORT, the
+   according stat information are stored in *STAT.  */
+error_t
+file_lookup (file_t dir, char *name, int flags0, int flags1,
+	     int mode, file_t *port, struct stat *stat)
+{
+  error_t err = 0;
+  file_t p;
+  struct stat s;
+
+  file_t do_file_lookup (file_t d, char *n, int f, int m)
+    {
+      if (port_valid (d))
+	p = file_name_lookup_under (d, n, f, m);
+      else if (errno == EACCES)
+	p = file_name_lookup (n, f, m);
+      return p;
+    }
+
+  p = do_file_lookup (dir, name, flags0, mode);
+  if (! port_valid (p))
+    p = do_file_lookup (dir, name, flags1, mode);
+
+  if (port_valid (p))
+    {
+      if (stat)
+	{
+	  err = io_stat (p, &s);
+	  if (err)
+	    port_dealloc (p);
+	}
+    }
+  else
+    err = errno;
+
+  if (! err)
+    {
+      *port = p;
+      if (stat)
+	*stat = s;
+    }
+  return err;
+}
+
+#include <fcntl.h>
+
+char *
+make_filepath (char *path, char *filename)
+{
+  int length;
+  char *filepath;
+
+  length = strlen (path) + strlen (filename) + 2;
+  filepath = malloc (length);
+  if (filepath == NULL) 
+    return NULL;
+  
+  strncpy (filepath, path, length);
+  strncat (filepath, filename, strlen (filename));
+
+  return filepath;
+}
+
+error_t
+for_each_subdir (char *path, error_t (*func) (char *, char *))
+{
+  struct dirent **dirent, **dirent_list;
+  char *dirent_data;
+  size_t dirent_data_size;
+  file_t dir;
+  error_t err;
+
+  dir = file_name_lookup (path, O_READ, 0);
+
+  err = dir_entries_get (dir, &dirent_data, &dirent_data_size, &dirent_list);
+  if (err)
+    return err;
+
+  for (dirent = dirent_list; (! err) && (*dirent); dirent++)
+    {
+      char *name;
+      struct stat filestat;
+
+      if ((!strcmp ((*dirent)->d_name, "."))
+	  || (!strcmp ((*dirent)->d_name, "..")))
+	continue;
+
+      name = make_filepath (path, (*dirent)->d_name);
+
+      err = stat (name, &filestat);
+
+      free (name);
+
+      if (err)
+	{
+	  fprintf (stderr, "unionfs: couldn't stat %s%s\n",
+		   path, (*dirent)->d_name);
+	  continue;
+	}
+
+      if (!S_ISDIR(filestat.st_mode))
+	continue;
+ 
+      func ((*dirent)->d_name, path);
+    }
+
+  return 0;
+}
+
+error_t
+for_each_subdir_priv (char *path, error_t (*func) (char *, char *, void *),
+		      void *priv)
+{
+  struct dirent **dirent, **dirent_list;
+  char *dirent_data;
+  size_t dirent_data_size;
+  file_t dir;
+  error_t err;
+
+  dir = file_name_lookup (path, O_READ, 0);
+
+  err = dir_entries_get (dir, &dirent_data, &dirent_data_size, &dirent_list);
+  if (err)
+    return err;
+
+  for (dirent = dirent_list; (!err) && (*dirent); dirent++)
+    {
+      char *name;
+      struct stat filestat;
+
+      if ((!strcmp ((*dirent)->d_name, "."))
+	  || (!strcmp ((*dirent)->d_name, "..")))
+	continue;
+
+      name = make_filepath (path, (*dirent)->d_name);
+
+      err = stat (name, &filestat);
+
+      free (name);
+
+      if (err)
+	{
+	  fprintf (stderr, "unionfs: couldn't stat %s%s\n",
+		   path, (*dirent)->d_name);
+	  continue;
+	}
+
+      if (!S_ISDIR(filestat.st_mode))
+	continue;
+ 
+      func ((*dirent)->d_name, path, priv);
+    }
+
+  return 0;
+}
+
+error_t
+for_each_file_priv (char *path, error_t (*func) (char *, char *, void *),
+		    void *priv)
+{
+  struct dirent **dirent, **dirent_list;
+  char *dirent_data;
+  size_t dirent_data_size;
+  file_t dir;
+  error_t err;
+
+  dir = file_name_lookup (path, O_READ, 0);
+
+  err = dir_entries_get (dir, &dirent_data, &dirent_data_size, &dirent_list);
+  if (err)
+    return err;
+
+  for (dirent = dirent_list; (!err) && (*dirent); dirent++)
+    {
+
+      if ((!strcmp ((*dirent)->d_name, "."))
+	  || (!strcmp ((*dirent)->d_name, "..")))
+	continue;
+
+      func ((*dirent)->d_name, path, priv);
+    }
+
+  return err;
+}
diff --git a/unionfs/lib.h b/unionfs/lib.h
new file mode 100644
index 00000000..be9a2192
--- /dev/null
+++ b/unionfs/lib.h
@@ -0,0 +1,82 @@
+/* Hurd unionfs
+   Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
+   Written by Moritz Schulte <moritz@duesseldorf.ccc.de>.
+
+   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 INCLUDED_LIB_H
+#define INCLUDED_LIB_H
+
+#include <hurd.h>
+#include <dirent.h>
+#include <stddef.h>
+
+/* Returned directory entries are aligned to blocks this many bytes
+   long.  Must be a power of two.  */
+#define DIRENT_ALIGN 4
+#define DIRENT_NAME_OFFS offsetof (struct dirent, d_name)
+
+/* Length is structure before the name + the name + '\0', all padded
+   to a four-byte alignment.  */
+#define DIRENT_LEN(name_len)                                 \
+  ((DIRENT_NAME_OFFS + (name_len) + 1 + (DIRENT_ALIGN - 1))  \
+   & ~(DIRENT_ALIGN - 1))
+
+/* These macros remove some Mach specific code from the server
+   itself.  */
+#define port_null MACH_PORT_NULL
+#define port_dealloc(p) mach_port_deallocate (mach_task_self (), (p))
+#define port_valid(p) ((p) != port_null)
+
+/* Fetch directory entries for DIR; store the raw data as returned by
+   the dir_readdir RPC in *DIRENT_DATA, the size of *DIRENT_DATA in
+   *DIRENT_DATA_SIZE and a list of pointers to the dirent structures
+   in *DIRENT_LIST.  */
+error_t dir_entries_get (file_t dir, char **dirent_data,
+			 size_t *dirent_data_size,
+			 struct dirent ***dirent_list);
+
+char *make_filepath (char *, char *);
+error_t for_each_subdir (char *, error_t (*) (char *, char *));
+error_t for_each_subdir_priv (char *, error_t (*) (char *, char *, void *),
+			      void *);
+
+/* Lookup the file named NAME beneath DIR (or the cwd, if DIR is not a
+   valid port.  Try to open with FLAGS0 first, and if that fails with
+   FLAGS1; MODE is the mode to user for newly created files.  On
+   success, stat the looked up port and store it in *PORT, the
+   according stat information are stored in *STAT.  */
+error_t file_lookup (file_t dir, char *name, int flags0, int flags1, int mode,
+		     file_t *port, struct stat *stat);
+
+/* Returns no error if directory.  */
+error_t check_dir (char *path);
+
+extern struct mutex debug_msg_lock;
+
+/* Support for debugging messages.  */
+#define debug_msg_send(fmt, args...)                         \
+        do                                                   \
+          {                                                  \
+            mutex_lock (&debug_msg_lock);                    \
+            fprintf (stderr, "%s:%i: ", __FILE__, __LINE__); \
+            fprintf (stderr, fmt , ## args);                 \
+            putc ('\n', stderr);                             \
+            mutex_unlock (&debug_msg_lock);                  \
+          }                                                  \
+        while (0)
+
+#endif
diff --git a/unionfs/lib.o b/unionfs/lib.o
new file mode 100644
index 00000000..aec53fdf
--- /dev/null
+++ b/unionfs/lib.o
diff --git a/unionfs/lnode.c b/unionfs/lnode.c
new file mode 100644
index 00000000..9b242bba
--- /dev/null
+++ b/unionfs/lnode.c
@@ -0,0 +1,184 @@
+/* Hurd unionfs
+   Copyright (C) 2001, 2002 Free Software Foundation, Inc.
+   Written by Moritz Schulte <moritz@duesseldorf.ccc.de>.
+
+   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.  */
+
+/* `light node' management.  See unionfs.h for an explanation of light
+   nodes.  */
+
+#define _GNU_SOURCE
+
+#include <hurd/netfs.h>
+#include <error.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "lnode.h"
+#include "lib.h"
+#include "unionfs.h"
+
+/* Create a new light node as an entry with the name NAME and store it
+   in *NODE.  The new node is not locked and contains a single
+   reference.  */
+error_t
+lnode_create (char *name, lnode_t **node)
+{
+  lnode_t *node_new = malloc (sizeof (lnode_t));
+  error_t err = 0;
+  
+  debug_msg ("lnode_create for name: %s", name);
+
+  if (! node_new)
+    err = ENOMEM;
+  else
+    {
+      char *name_cp = NULL;
+
+      if (name)
+	name_cp = strdup (name);
+      if (name && (! name_cp))
+	{
+	  err = ENOMEM;
+	  free (node_new);
+	}
+      else
+	{
+	  node_new->name = name_cp;
+	  node_new->name_len = name_cp ? strlen (name_cp) : 0;
+	  node_new->flags = 0;
+	  node_new->node = NULL;
+	  node_new->next = NULL;
+	  node_new->prevp = NULL;
+	  node_new->dir = NULL;
+	  node_new->entries = NULL;
+	  node_new->references = 1;
+	  mutex_init (&node_new->lock);
+	  mutex_lock (&node_new->lock);
+	  *node = node_new;
+	}
+    }
+  return err;
+}
+
+/* Destroy a light node.  */
+void
+lnode_destroy (lnode_t *node)
+{
+  debug_msg ("lnode_destroy for name: %s", node->name);
+  free (node->name);
+  free (node);
+}
+
+/* Install the node in the node tree; add a reference to DIR, which
+   must be locked.  */
+void
+lnode_install (lnode_t *dir, lnode_t *node)
+{
+  lnode_ref_add (dir);
+  node->next = dir->entries;
+  node->prevp = &dir->entries;
+  if (dir->entries)
+    dir->entries->prevp = &node->next;
+  dir->entries = node;
+  node->dir = dir;
+}
+
+/* Uninstall the node from the node tree; remove a reference from the
+   lnode containing NODE.  */
+void
+lnode_uninstall (lnode_t *node)
+{
+  lnode_ref_remove (node->dir);
+  *node->prevp = node->next;
+  if (node->next)
+    node->next->prevp = &node->next;
+}
+
+/* Add a reference to NODE, which must be locked.  */
+void
+lnode_ref_add (lnode_t *node)
+{
+  node->references++;
+}
+
+/* Remove a reference to NODE, which must be locked.  If that was the
+   last reference, destroy the node, otherwise simply unlock NODE.  */
+void
+lnode_ref_remove (lnode_t *node)
+{
+  assert (node->references);
+  if (! --node->references)
+    {
+      lnode_uninstall (node);
+      lnode_destroy (node);
+    }
+  else
+    mutex_unlock (&node->lock);
+}
+
+/* Get a light node by it's name.  The looked up node is locked and
+   got one reference added.  */
+error_t
+lnode_get (lnode_t *dir, char *name,
+	   lnode_t **node)
+{
+  error_t err = 0;
+  lnode_t *n;
+
+  for (n = dir->entries; n && strcmp (n->name, name); n = n->next);
+  if (n)
+    {
+      mutex_lock (&n->lock);
+      lnode_ref_add (n);
+      *node = n;
+    }
+  else
+    err = ENOENT;
+
+  return err;
+}
+
+/* Construct the full path for a given light node.  */
+error_t
+lnode_path_construct (lnode_t *node,
+		      char **path)
+{
+  error_t err = 0;
+  int p_len = 1;
+  lnode_t *n;
+  char *p;
+
+  for (n = node; n && n->dir; n = n->dir)
+    p_len += n->name_len + (n->dir->dir ? 1 : 0);
+
+  p = malloc (p_len);
+  if (! p)
+    err = ENOMEM;
+  else
+    {
+      *(p + --p_len) = 0;
+      for (n = node; n && n->dir; n = n->dir)
+	{
+	  p_len -= n->name_len;
+	  strncpy (p + p_len, n->name, n->name_len);
+	  if (n->dir->dir)
+	    *(p + --p_len) = '/';
+	}
+      *path = p;
+    }
+  return err;
+}
diff --git a/unionfs/lnode.h b/unionfs/lnode.h
new file mode 100644
index 00000000..b43b7b26
--- /dev/null
+++ b/unionfs/lnode.h
@@ -0,0 +1,77 @@
+/* Hurd unionfs
+   Copyright (C) 2001, 2002 Free Software Foundation, Inc.
+   Written by Moritz Schulte <moritz@duesseldorf.ccc.de>.
+
+   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.  */
+
+/* `light node' management.  */
+
+#ifndef INCLUDED_LNODE_H
+#define INCLUDED_LNODE_H
+
+#include <hurd/netfs.h>
+#include <error.h>
+
+struct lnode
+{
+  char *name;			/* The name of this light node.  */
+  int name_len;			/* This is used quite often and since
+				   NAME does not change, just
+				   calculate it once.  */
+  int flags;			/* Associated flags.  */
+  int references;		/* References to this light node.  */
+  struct node *node;	        /* Reference to the real node.  */
+  struct lnode *next, **prevp;	/* Light nodes are connected in a
+				   linked list.  */
+  struct lnode *dir;		/* The light node this light node is
+				   contained int.  */
+  struct lnode *entries;	/* A reference to the list containing
+				   the entries of this light node.  */
+  struct mutex lock;		/* A lock.  */
+};
+typedef struct lnode lnode_t;
+
+/* Create a new light node as an entry with the name NAME and store it
+   in *NODE.  The new node is not locked and contains a single
+   reference.  */
+error_t lnode_create (char *name, lnode_t **node);
+
+/* Destroy a light node.  */
+void lnode_destroy (lnode_t *node);
+
+/* Install the node in the node tree; add a reference to DIR.  */
+void lnode_install (lnode_t *dir, lnode_t *node);
+
+/* Uninstall the node from the node tree; remove a reference from the
+   lnode containing NODE.  */
+void lnode_uninstall (lnode_t *node);
+
+/* Add a reference to NODE, which must be locked.  */
+void lnode_ref_add (lnode_t *node);
+
+/* Remove a reference to NODE, which must be locked.  If that was the
+   last reference, destroy the node, otherwise simply unlock NODE.  */
+void lnode_ref_remove (lnode_t *node);
+
+/* Get a light node by it's name.  The looked up node is locked and
+   got one reference added.  */
+error_t lnode_get (lnode_t *dir, char *name,
+		   lnode_t **node);
+
+/* Construct the full path for a given light node.  */
+error_t lnode_path_construct (lnode_t *node, char **path);
+
+#endif
diff --git a/unionfs/lnode.o b/unionfs/lnode.o
new file mode 100644
index 00000000..bcd1154f
--- /dev/null
+++ b/unionfs/lnode.o
diff --git a/unionfs/main.c b/unionfs/main.c
new file mode 100644
index 00000000..c33b0654
--- /dev/null
+++ b/unionfs/main.c
@@ -0,0 +1,134 @@
+/* Hurd unionfs
+   Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
+   Written by Moritz Schulte <moritz@duesseldorf.ccc.de>.
+
+   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 <hurd/netfs.h>
+#include <argp.h>
+#include <argz.h>
+#include <error.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "version.h"
+#include "unionfs.h"
+#include "ncache.h"
+#include "ulfs.h"
+#include "lnode.h"
+#include "node.h"
+#include "options.h"
+#include "stow.h"
+#include "update.h"
+
+char *netfs_server_name = "unionfs";
+char *netfs_server_version = HURD_VERSION;
+
+/* Not really needed, since unionfs doesn't manage symlinks.  */
+int netfs_maxsymlinks = 0;
+
+/* Flags describing certain properties of the unionfs.  */
+int unionfs_flags;
+
+/* The filesystem id (the pid).  */
+pid_t fsid;
+
+/* A port to the underlying node.  */
+mach_port_t underlying_node;
+
+/* stat information for the underlying node.  */
+struct stat underlying_node_stat;
+
+/* Mapped time, used for updating node information.  */
+volatile struct mapped_time_value *maptime;
+
+/* Used by netfs_set_options to handle runtime option parsing.  */
+struct argp *netfs_runtime_argp = &argp_runtime;
+
+/* Main entry point.  */
+int
+main (int argc, char **argv)
+{
+  mach_port_t bootstrap_port;
+  error_t err = 0;
+
+  root_update_init ();
+
+  err = stow_init();
+  if (err)
+    error (EXIT_FAILURE, err, "failed to initialize stow support");
+
+  /* Argument parsing.  */
+  argp_parse (&argp_startup, argc, argv, ARGP_IN_ORDER, 0, 0);
+
+  err = node_create_root (&netfs_root_node);
+  if (err)
+    error (EXIT_FAILURE, err, "failed to create root node");
+
+  /* netfs initialization.  */
+  task_get_bootstrap_port (mach_task_self (), &bootstrap_port);
+  netfs_init ();
+  underlying_node = netfs_startup (bootstrap_port, O_READ);
+
+  err = node_init_root (netfs_root_node);
+  if (err)
+    error (EXIT_FAILURE, err, "failed to initialize root node");
+
+  /* Map the time, used for updating node information.  */
+  err = maptime_map (0, 0, &maptime);
+  if (err)
+    error (EXIT_FAILURE, err, "maptime_map");
+
+  /* More initialiazation.  */
+  ncache_init (ncache_size);
+
+  /* Here we adjust the root node permissions.  */
+  err = io_stat (underlying_node, &underlying_node_stat);
+
+  if (err)
+    error (EXIT_FAILURE, err, "io_stat");
+
+  fsid = getpid ();
+  netfs_root_node->nn_stat = underlying_node_stat;
+  netfs_root_node->nn_stat.st_ino = UNIONFS_ROOT_INODE; /* FIXME.  */
+  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);
+  netfs_root_node->nn_translated = netfs_root_node->nn_stat.st_mode;
+  
+  /* If the underlying node isn't a directory, enhance the stat
+     information.  */
+  if (! S_ISDIR (underlying_node_stat.st_mode))
+    {
+      if (underlying_node_stat.st_mode & S_IRUSR)
+	netfs_root_node->nn_stat.st_mode |= S_IXUSR;
+      if (underlying_node_stat.st_mode & S_IRGRP)
+	netfs_root_node->nn_stat.st_mode |= S_IXGRP;
+      if (underlying_node_stat.st_mode & S_IROTH)
+	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);
+
+  /* Start serving clients.  */
+  for (;;)
+    netfs_server_loop ();
+}
diff --git a/unionfs/main.o b/unionfs/main.o
new file mode 100644
index 00000000..59e2336a
--- /dev/null
+++ b/unionfs/main.o
diff --git a/unionfs/ncache.c b/unionfs/ncache.c
new file mode 100644
index 00000000..4c83ac0e
--- /dev/null
+++ b/unionfs/ncache.c
@@ -0,0 +1,151 @@
+/* Hurd unionfs
+   Copyright (C) 2001, 2002 Free Software Foundation, Inc.
+   Written by Moritz Schulte <moritz@duesseldorf.ccc.de>.
+
+   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 <hurd/netfs.h>
+#include <error.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#include "ncache.h"
+#include "lib.h"
+#include "unionfs.h"
+
+/* The node cache.  */
+ncache_t ncache;
+
+/* Cache size, may be overwritten by the user.  */
+int ncache_size = NCACHE_SIZE;
+
+/* Initialize the node cache, set the maximum number of allowed nodes
+   in the cache to SIZE_MAX.  */
+void
+ncache_init (int size_max)
+{
+  ncache.mru = NULL;
+  ncache.lru = NULL;
+  ncache.size_max = size_max;
+  ncache.size_current = 0;
+  mutex_init (&ncache.lock);
+}
+
+/* Remove the given node NODE from the cache.  */
+static void
+ncache_node_remove (node_t *node)
+{
+  struct netnode *nn = node->nn;
+
+  if (nn->ncache_next)
+    nn->ncache_next->nn->ncache_prev = nn->ncache_prev;
+  if (nn->ncache_prev)
+    nn->ncache_prev->nn->ncache_next = nn->ncache_next;
+  if (ncache.mru == node)
+    ncache.mru = nn->ncache_next;
+  if (ncache.lru == node)
+    ncache.lru = nn->ncache_prev;
+  nn->ncache_next = NULL;
+  nn->ncache_prev = NULL;
+  ncache.size_current--;
+}
+
+void
+ncache_reset (void)
+{
+  node_t *node;
+
+  mutex_lock (&ncache.lock);
+  while ((node = ncache.mru))
+    ncache_node_remove (node);
+  mutex_unlock (&ncache.lock);
+}
+
+/* Lookup the node for the light node LNODE.  If it does not exist
+   anymore in the cache, create a new node.  Store the looked up node
+   in *NODE.  */
+error_t
+ncache_node_lookup (lnode_t *lnode, node_t **node)
+{
+  error_t err = 0;
+  node_t *n;
+
+  if (lnode->node)
+    {
+      debug_msg ("ncache_node_lookup for lnode: %s (found in cache)",
+		 lnode->name);
+      n = lnode->node;
+      netfs_nref (n);
+    }
+  else
+    {
+      debug_msg ("ncache_node_lookup for lnode: %s (newly created)",
+		 lnode->name);
+      err = node_create (lnode, &n);
+    }
+
+  if (! err)
+    {
+      mutex_lock (&n->lock);
+      *node = n;
+    }
+  return err;
+}
+
+/* Add the given node NODE to the node cache; remove
+   least-recently-used nodes, if needed.  */
+void
+ncache_node_add (node_t *node)
+{
+  mutex_lock (&ncache.lock);
+
+  debug_msg ("adding node to cache: %s", node->nn->lnode->name);
+
+  if (ncache.size_max > 0 || ncache.size_current > 0)
+    {
+      if (ncache.mru != node)
+	{
+	  if (node->nn->ncache_next || node->nn->ncache_prev)
+	    /* Node is already in the cache.  */
+	    ncache_node_remove (node);
+	  else
+	    /* Add a reference from the cache.  */
+	    netfs_nref (node);
+	  
+	  node->nn->ncache_next = ncache.mru;
+	  node->nn->ncache_prev = NULL;
+	  if (ncache.mru)
+	    ncache.mru->nn->ncache_prev = node;
+	  if (! ncache.lru)
+	    ncache.lru = node;
+	  ncache.mru = node;
+	  ncache.size_current++;
+	}
+    }
+
+  /* Forget the least used nodes.  */
+  while (ncache.size_current > ncache.size_max)
+    {
+      struct node *lru = ncache.lru;
+      debug_msg ("removing cached node: %s", lru->nn->lnode->name);
+      ncache_node_remove (lru);
+      netfs_nrele (lru);
+    }
+
+  mutex_unlock (&ncache.lock);
+}
diff --git a/unionfs/ncache.h b/unionfs/ncache.h
new file mode 100644
index 00000000..8fa7d107
--- /dev/null
+++ b/unionfs/ncache.h
@@ -0,0 +1,59 @@
+/* Hurd unionfs
+   Copyright (C) 2001, 2002 Free Software Foundation, Inc.
+   Written by Moritz Schulte <moritz@duesseldorf.ccc.de>.
+
+   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 INCLUDED_NCACHE_H
+#define INCLUDED_NCACHE_H
+
+#include <error.h>
+#include <hurd/netfs.h>
+
+#include "node.h"
+
+typedef struct ncache
+{
+  node_t *mru; 		        /* Reference to the mru end of the
+				   cache chain.  */
+  node_t *lru;		        /* Reference to the lru end of the
+				   cache chain.  */
+  int size_max;			/* Maximal number of nodes to
+				   cache.  */
+  int size_current;		/* Current number of nodes in the
+				   cache.  */
+  struct mutex lock;		/* A lock.  */
+} ncache_t;
+
+/* Cache size, may be overwritten by the user.  */
+extern int ncache_size;
+
+/* Initialize the node cache, set the maximum number of allowed nodes
+   in the cache to SIZE_MAX.  */
+void ncache_init (int size_max);
+
+/* Lookup the node for the light node LNODE.  If it does not exist
+   anymore in the cache, create a new node.  Store the looked up node
+   in *NODE.  */
+error_t ncache_node_lookup (lnode_t *lnode, node_t **node);
+
+void ncache_reset (void);
+
+/* Add the given node NODE to the node cache; remove
+   least-recently-used nodes, if needed.  */
+void ncache_node_add (node_t *node);
+
+#endif
diff --git a/unionfs/ncache.o b/unionfs/ncache.o
new file mode 100644
index 00000000..79c064b3
--- /dev/null
+++ b/unionfs/ncache.o
diff --git a/unionfs/netfs.c b/unionfs/netfs.c
new file mode 100644
index 00000000..89d1bf67
--- /dev/null
+++ b/unionfs/netfs.c
@@ -0,0 +1,1170 @@
+/* Hurd unionfs
+   Copyright (C) 2001, 2002, 2003, 2005 Free Software Foundation, Inc.
+   Written by Moritz Schulte <moritz@duesseldorf.ccc.de>.
+
+   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 <hurd/netfs.h>
+#include <error.h>
+#include <argz.h>
+#include <stddef.h>
+#include <fcntl.h>
+#include <assert.h>
+#include <string.h>
+#include <stdio.h>
+#include <hurd/paths.h>
+#include <sys/mman.h>
+
+#include "unionfs.h"
+#include "ulfs.h"
+#include "node.h"
+#include "lib.h"
+#include "ncache.h"
+#include "options.h"
+
+/* Return an argz string describing the current options.  Fill *ARGZ
+   with a pointer to newly malloced storage holding the list and *LEN
+   to the length of that storage.  */
+error_t
+netfs_append_args (char **argz, size_t *argz_len)
+{
+  error_t err = 0;
+
+  ulfs_iterate
+    {
+      if (! err)
+	if (unionfs_flags & FLAG_UNIONFS_MODE_DEBUG)
+	  err = argz_add (argz, argz_len,
+			  OPT_LONG (OPT_LONG_DEBUG));
+      if (! err)
+	if (ulfs->flags & FLAG_ULFS_WRITABLE)
+	  err = argz_add (argz, argz_len,
+			  OPT_LONG (OPT_LONG_WRITABLE));
+      if (! err)
+	if (ulfs->priority)
+	  {
+	    char *buf = NULL;
+	    if ((err = asprintf (&buf, "%s=%s", OPT_LONG (OPT_LONG_PRIORITY), 
+		      ulfs->priority)) != -1)
+	      {
+		err = argz_add (argz, argz_len, buf);
+		free (buf);
+	      }
+	  }
+
+      if (! err)
+	{
+	  if (ulfs->path)
+	    err = argz_add (argz, argz_len, ulfs->path);
+	  else
+	    err = argz_add (argz, argz_len,
+			    OPT_LONG (OPT_LONG_UNDERLYING));
+	}
+    }
+
+  return err;
+}
+
+#ifndef __USE_FILE_OFFSET64
+#define OFFSET_T __off_t		/* Size in bytes.  */
+#else
+#define OFFSET_T __off64_t		/* Size in bytes.  */
+#endif
+
+static error_t
+_get_node_size (struct node *dir, OFFSET_T *off)
+{
+  size_t size = 0;
+  error_t err;
+  int count = 0;
+  node_dirent_t *dirent_start, *dirent_current;
+  node_dirent_t *dirent_list = NULL;
+  int first_entry = 2;
+  
+  int bump_size (const char *name)
+    {
+      size_t new_size = size + DIRENT_LEN (strlen (name));
+      
+      size = new_size;
+      count ++;
+      return 1;
+    }
+  
+  err = node_entries_get (dir, &dirent_list);
+  if (err)
+    return err;
+  
+  for (dirent_start = dirent_list, count = 2;
+       dirent_start && first_entry > count;
+       dirent_start = dirent_start->next, count++);
+  
+  count = 0;
+  
+  /* Make space for the `.' and `..' entries.  */
+  if (first_entry == 0)
+    bump_size (".");
+  if (first_entry <= 1)
+    bump_size ("..");
+  
+  /* See how much space we need for the result.  */
+  for (dirent_current = dirent_start;
+       dirent_current;
+       dirent_current = dirent_current->next)
+    if (! bump_size (dirent_current->dirent->d_name))
+      break;
+
+  free (dirent_list);
+
+  *off = size;
+
+  return 0;
+}
+
+
+/* Make sure that NP->nn_stat is filled with current information.
+   CRED identifies the user responsible for the operation. */
+error_t
+netfs_validate_stat (struct node *np, struct iouser *cred)
+{
+  error_t err = 0;
+
+  if (np != netfs_root_node)
+    {
+      if (! (np->nn->flags & FLAG_NODE_ULFS_UPTODATE))
+	err = node_update (np);
+      if (! err)
+	{
+	  int done = 0;
+
+	  node_ulfs_iterate_unlocked (np)
+	    if ((! done) && port_valid (node_ulfs->port))
+	      {
+		err = io_stat (node_ulfs->port, &np->nn_stat);
+		if (! err)
+		  np->nn_translated = np->nn_stat.st_mode;
+		done = 1;
+	      }
+	  if (! done)
+	    err = ENOENT;	/* FIXME?  */
+	}
+    }
+  else 
+    {
+      _get_node_size (np, &np->nn_stat.st_size); 
+    }
+
+  return err;
+}
+
+/* This should attempt a chmod call for the user specified by CRED on
+   locked node NP, to change the owner to UID and the group to GID.  */
+error_t
+netfs_attempt_chown (struct iouser *cred, struct node *np,
+		     uid_t uid, uid_t gid)
+{
+  return EOPNOTSUPP;
+}
+
+/* This should attempt a chauthor call for the user specified by CRED
+   on locked node NP, thereby changing the author to AUTHOR.  */
+error_t
+netfs_attempt_chauthor (struct iouser *cred, struct node *np,
+			uid_t author)
+{
+  return EOPNOTSUPP;
+}
+
+/* This should attempt a chmod call for the user specified by CRED on
+   locked node NODE, to change the mode to MODE.  Unlike the normal
+   Unix and Hurd meaning of chmod, this function is also used to
+   attempt to change files into other types.  If such a transition is
+   attempted which is impossible, then return EOPNOTSUPP.  */
+error_t
+netfs_attempt_chmod (struct iouser *cred, struct node *np,
+		     mode_t mode)
+{
+  return EOPNOTSUPP;
+}
+
+/* Attempt to turn locked node NP (user CRED) into a symlink with
+   target NAME.  */
+error_t
+netfs_attempt_mksymlink (struct iouser *cred, struct node *np,
+			 char *name)
+{
+  return EOPNOTSUPP;
+}
+
+/* Attempt to turn NODE (user CRED) into a device.  TYPE is either
+   S_IFBLK or S_IFCHR.  NP is locked.  */
+error_t
+netfs_attempt_mkdev (struct iouser *cred, struct node *np,
+		     mode_t type, dev_t indexes)
+{
+  return EOPNOTSUPP;
+}
+
+/* Attempt to set the passive translator record for FILE to ARGZ (of
+   length ARGZLEN) for user CRED. NP is locked.  */
+error_t
+netfs_set_translator (struct iouser *cred, struct node *np,
+		      char *argz, size_t argzlen)
+{
+  return EOPNOTSUPP;
+}
+
+/* For locked node NODE with S_IPTRANS set in its mode, look up the
+   name of its translator.  Store the name into newly malloced
+   storage, and return it in *ARGZ; set *ARGZ_LEN to the total length.  */
+error_t
+netfs_get_translator (struct node *node, char **argz,
+		      size_t *argz_len)
+{
+  return EOPNOTSUPP;
+}
+
+/* This should attempt a chflags call for the user specified by CRED
+   on locked node NP, to change the flags to FLAGS.  */
+error_t
+netfs_attempt_chflags (struct iouser *cred, struct node *np,
+		       int flags)
+{
+  return EOPNOTSUPP;
+}
+
+/* This should attempt a utimes call for the user specified by CRED on
+   locked node NP, to change the atime to ATIME and the mtime to
+   MTIME.  If ATIME or MTIME is null, then set to the current time.  */
+error_t
+netfs_attempt_utimes (struct iouser *cred, struct node *np,
+		      struct timespec *atime, struct timespec *mtime)
+{
+  return 0;
+}
+
+/* This should attempt to set the size of the locked file NP (for user
+   CRED) to SIZE bytes long.  */
+error_t
+netfs_attempt_set_size (struct iouser *cred, struct node *np,
+			off_t size)
+{
+  return EOPNOTSUPP;
+}
+
+/* This should attempt to fetch filesystem status information for the
+   remote filesystem, for the user CRED. NP is locked.  */
+error_t
+netfs_attempt_statfs (struct iouser *cred, struct node *np,
+		      struct statfs *st)
+{
+  return EOPNOTSUPP;
+}
+
+/* This should sync the locked file NP completely to disk, for the
+   user CRED.  If WAIT is set, return only after the sync is
+   completely finished.  */
+error_t
+netfs_attempt_sync (struct iouser *cred, struct node *np,
+		    int wait)
+{
+  return EOPNOTSUPP;
+}
+
+/* This should sync the entire remote filesystem.  If WAIT is set,
+   return only after the sync is completely finished.  */
+error_t
+netfs_attempt_syncfs (struct iouser *cred, int wait)
+{
+  return 0;
+}
+
+/* lookup */
+
+/* We don't use this functions, but it has to be defined.  */
+error_t
+netfs_attempt_lookup (struct iouser *user, struct node *dir,
+		      char *name, struct node **node)
+{
+  return EOPNOTSUPP;
+}
+
+/* Delete NAME in DIR (which is locked) for USER.  */
+error_t
+netfs_attempt_unlink (struct iouser *user, struct node *dir,
+		      char *name)
+{
+  error_t err = 0;
+  mach_port_t p;
+  struct stat statbuf;
+
+  node_update (dir);
+
+  err = node_lookup_file (dir, name, 0, &p, &statbuf);
+  if (err)
+      return err;
+
+  port_dealloc (p);
+
+  err = fshelp_checkdirmod (&dir->nn_stat, &statbuf, user);
+  if (err)
+      return err;
+
+  err = node_unlink_file (dir, name);
+
+  return err;
+}
+
+/* Attempt to rename the directory FROMDIR to TODIR. Note that neither
+   of the specific nodes are locked.  */
+error_t
+netfs_attempt_rename (struct iouser *user, struct node *fromdir,
+		      char *fromname, struct node *todir, 
+		      char *toname, int excl)
+{
+  return EOPNOTSUPP;
+}
+
+/* Attempt to create a new directory named NAME in DIR (which is
+   locked) for USER with mode MODE. */
+error_t
+netfs_attempt_mkdir (struct iouser *user, struct node *dir,
+		     char *name, mode_t mode)
+{
+  error_t err = 0;
+  mach_port_t p;
+  struct stat statbuf;
+
+  node_update (dir);
+
+  err = fshelp_checkdirmod (&dir->nn_stat, 0, user);
+  if (err)
+    goto exit;
+
+  /* Special case for no UID processes (like login shell).  */
+  if ((!user->uids->ids) || (!user->uids->ids))
+    {
+      err = EACCES;
+      goto exit;
+    }
+
+  err = node_dir_create (dir, name, mode);
+  if (err)
+    goto exit;
+
+  err = node_lookup_file (dir, name, 0, &p, &statbuf);
+  if (err)
+    {
+      node_dir_remove (dir, name);
+      goto exit;
+    }
+
+  err = file_chown (p, user->uids->ids[0], user->gids->ids[0]);
+  if (err)
+    {
+      port_dealloc (p);
+      node_dir_remove (dir, name);
+      goto exit;
+    }
+
+  port_dealloc (p);
+
+ exit:
+
+  return err;
+}
+
+/* Attempt to remove directory named NAME in DIR (which is locked) for
+   USER.  */
+error_t
+netfs_attempt_rmdir (struct iouser *user, 
+		     struct node *dir, char *name)
+{
+  error_t err = 0;
+  mach_port_t p;
+  struct stat statbuf;
+
+  node_update (dir);
+
+  err = node_lookup_file (dir, name, 0, &p, &statbuf);
+  if (err)
+      return err;
+
+  port_dealloc (p);
+
+  err = fshelp_checkdirmod (&dir->nn_stat, &statbuf, user);
+  if (err)
+      return err;
+
+  err = node_dir_remove (dir, name);
+
+  return err;
+}
+
+/* Create a link in DIR with name NAME to FILE for USER. Note that
+   neither DIR nor FILE are locked. If EXCL is set, do not delete the
+   target.  Return EEXIST if NAME is already found in DIR.  */
+error_t
+netfs_attempt_link (struct iouser *user, struct node *dir,
+		    struct node *file, char *name, int excl)
+{
+  return EOPNOTSUPP;
+}
+
+/* Attempt to create an anonymous file related to DIR (which is
+   locked) for USER with MODE.  Set *NP to the returned file upon
+   success. No matter what, unlock DIR.  */
+error_t
+netfs_attempt_mkfile (struct iouser *user, struct node *dir,
+		      mode_t mode, struct node **np)
+{
+  mutex_unlock (&dir->lock);
+  return EOPNOTSUPP;
+}
+
+/* (We don't use this function!)  Attempt to create a file named NAME
+   in DIR (which is locked) for USER with MODE.  Set *NP to the new
+   node upon return.  On any error, clear *NP.  *NP should be locked
+   on success; no matter what, unlock DIR before returning.  */
+error_t
+netfs_attempt_create_file (struct iouser *user, struct node *dir,
+			   char *name, mode_t mode, struct node **np)
+{
+  mutex_unlock (&dir->lock);
+  return EOPNOTSUPP;
+}
+
+/* We use this local interface to attempt_create file since we are
+   using our own netfs_S_dir_lookup.  */
+error_t
+netfs_attempt_create_file_reduced (struct iouser *user, struct node *dir,
+				   char *name, mode_t mode, int flags)
+{
+  mach_port_t p;
+  error_t err;
+  struct stat statbuf;
+
+  node_update (dir);
+
+  err = fshelp_checkdirmod (&dir->nn_stat, 0, user);
+  if (err)
+    goto exit;
+
+  /* Special case for no UID processes (like login shell).  */
+  if ((!user->uids->ids) || (!user->uids->ids))
+    {
+      err = EACCES;
+      goto exit;
+    }
+  
+  mutex_unlock (&dir->lock);
+  err = node_lookup_file (dir, name, flags | O_CREAT, 
+			  &p, &statbuf);
+  mutex_lock (&dir->lock);
+
+  if (err)
+    goto exit;
+
+  err = file_chmod (p, mode);
+  if (err)
+    {
+      port_dealloc (p);
+      node_unlink_file (dir, name);
+      goto exit;
+    }
+
+  err = file_chown (p, user->uids->ids[0], user->gids->ids[0]);
+  if (err)
+    {
+      port_dealloc (p);
+      node_unlink_file (dir, name);
+      goto exit;
+    }
+
+  err = io_stat (p, &statbuf);
+
+  /* Check file permissions.  */
+  if (! err && (flags & O_READ))
+    err = fshelp_access (&statbuf, S_IREAD, user);
+  if (! err && (flags & O_WRITE))
+    err = fshelp_access (&statbuf, S_IWRITE, user);
+  if (! err && (flags & O_EXEC))
+    err = fshelp_access (&statbuf, S_IEXEC, user);
+  
+  if (err)
+    {
+      port_dealloc (p);
+      node_unlink_file (dir, name);
+      goto exit;
+    }
+
+  port_dealloc (p);
+  
+ exit:
+  mutex_unlock (&dir->lock);
+  return err;
+}
+
+/* Read the contents of locked node NP (a symlink), for USER, into
+   BUF.  */
+error_t
+netfs_attempt_readlink (struct iouser *user, struct node *np,
+			char *buf)
+{
+  return EOPNOTSUPP;
+}
+
+/* libnetfs uses this functions once.  */
+error_t
+netfs_check_open_permissions (struct iouser *user, struct node *np,
+			      int flags, int newnode)
+{
+  error_t err = 0;
+
+  if (! err && (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 err;
+}
+
+/* Read from the locked file NP for user CRED starting at OFFSET and
+   continuing for up to *LEN bytes.  Put the data at DATA.  Set *LEN
+   to the amount successfully read upon return.  */
+error_t
+netfs_attempt_read (struct iouser *cred, struct node *np,
+		    off_t offset, size_t *len, void *data)
+{
+  *len = 0;
+  return 0;
+}
+
+/* Write to the locked file NP for user CRED starting at OFSET and
+   continuing for up to *LEN bytes from DATA.  Set *LEN to the amount
+   successfully written upon return.  */
+error_t
+netfs_attempt_write (struct iouser *cred, struct node *np,
+		     off_t offset, size_t *len, void *data)
+{
+  /* Since unionfs only manages directories...  */
+  return EISDIR;
+}
+
+/* Return the valid access types (bitwise OR of O_READ, O_WRITE, and
+   O_EXEC) in *TYPES for locked file NP and user CRED.  */
+error_t
+netfs_report_access (struct iouser *cred, struct node *np,
+		     int *types)
+{
+  *types = 0;
+  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;
+  return 0;
+}
+
+/* Create a new user from the specified UID and GID arrays.  */
+struct iouser *
+netfs_make_user (uid_t *uids, int nuids, uid_t *gids, int ngids)
+{
+  return NULL;
+}
+
+/* Node NP has no more references; free all its associated storage.  */
+void
+netfs_node_norefs (struct node *np)
+{
+  node_destroy (np);
+}
+
+error_t
+netfs_attempt_lookup_improved (struct iouser *user, struct node *dir,
+			       char *name, struct node **np,
+			       int flags, int lastcomp,
+			       mach_port_t *port,
+			       mach_msg_type_name_t *port_type)
+{
+  mach_port_t p;
+  error_t err;
+
+  mutex_lock (&dir->nn->lnode->lock);
+
+  err = fshelp_access (&dir->nn_stat, S_IEXEC, user);
+  if (err)
+      goto exit;
+  
+
+  if (! *name || ! strcmp (name, "."))
+    {
+
+      /* The same node is wanted.  */
+      *np = dir;
+      netfs_nref (*np);
+
+    }
+  else if (! strcmp (name, ".."))
+    {
+
+      /* We have to get the according light node first.  */
+      lnode_t *lnode = dir->nn->lnode;
+      node_t *node;
+
+      err = ncache_node_lookup (lnode->dir, &node);
+      if (err)
+	goto exit;
+	      
+      *np = node;
+      
+    }
+  else 
+    {
+
+      lnode_t *dir_lnode = dir->nn->lnode;
+      struct stat statbuf;
+      lnode_t *lnode = NULL;
+
+      /* Lookup the node by it's name on the underlying
+	 filesystems.  */
+
+      err = node_update (dir);
+
+      /* We have to unlock this node while doing lookups.  */
+      mutex_unlock (&dir_lnode->lock);
+      mutex_unlock (&dir->lock);
+
+      err = node_lookup_file (dir, name, flags & ~(O_NOLINK|O_CREAT),
+			      &p, &statbuf);
+
+      mutex_lock (&dir->lock);
+      mutex_lock (&dir_lnode->lock);
+
+
+      if (err)
+	goto exit;
+
+      if (S_ISDIR (statbuf.st_mode))
+	{
+	  node_t *node;
+
+	  /* We don't need this port directly.  */
+	  port_dealloc (p);
+	  
+	  /* The found node is a directory, so we have to manage the
+	     node.  First we need the light node.  */
+
+	  err = lnode_get (dir_lnode, name, &lnode);
+	  if (err == ENOENT)
+	    {
+	      /* It does not exist, we have to create it.  */
+	      err = lnode_create (name, &lnode);
+	      if (err)
+		goto exit;
+	      
+	      lnode_install (dir_lnode, lnode);
+	    }
+	  
+	  /* Now we have a light node.  */
+	  err = ncache_node_lookup (lnode, &node);
+	  
+	  /* This unlocks the node for us.  */
+	  lnode_ref_remove (lnode);
+
+	  if (err)
+	      goto exit;
+	  
+	  /* Got the node.  */
+	  *np = node;
+	  
+	}
+      else 
+	{
+	  /* The found node is not a directory.  */
+	  mach_port_t p_restricted;
+
+	  if (! lastcomp)
+	    {
+	      /* We have not reached the last path component yet.  */
+	      port_dealloc (p);
+	      err = ENOTDIR;
+	      goto exit;
+	    }
+
+	  /* Check file permissions.  */
+	  if (! err && (flags & O_READ))
+	    err = fshelp_access (&statbuf, S_IREAD, user);
+	  if (! err && (flags & O_WRITE))
+	    err = fshelp_access (&statbuf, S_IWRITE, user);
+	  if (! err && (flags & O_EXEC))
+	    err = fshelp_access (&statbuf, S_IEXEC, user);
+
+	  if (err)
+	    {
+	      port_dealloc (p);
+	      goto exit;
+	    }
+
+
+	  /* A file node is successfully looked up.  */
+	  err = io_restrict_auth (p, &p_restricted,
+				  user->uids->ids, user->uids->num,
+				  user->gids->ids, user->gids->num);
+	  port_dealloc (p);
+	  
+	  if (err)
+	    goto exit;
+	  
+	  /* Successfully restricted.  */
+	  *port = p_restricted;
+	  *port_type = MACH_MSG_TYPE_MOVE_SEND;
+	}
+    }
+  
+ exit: 
+
+  if (err)
+    *np = NULL;
+  else if (*np)
+    {
+      mutex_unlock (&(*np)->lock);
+      ncache_node_add (*np);
+    }
+
+  mutex_unlock (&dir->nn->lnode->lock);
+  mutex_unlock (&dir->lock);
+  return err;
+}
+
+/* We need our own, special implementation of netfs_S_dir_lookup,
+   because libnetfs does not (yet?) know about cases, in which the
+   servers wants to return (foreign) ports directly to the user,
+   instead of usual node structures.  */
+
+#define OPENONLY_STATE_MODES (O_CREAT|O_EXCL|O_NOLINK|O_NOTRANS|O_NONBLOCK)
+
+fshelp_fetch_root_callback1_t _netfs_translator_callback1;
+fshelp_fetch_root_callback2_t _netfs_translator_callback2;
+
+error_t
+netfs_S_dir_lookup (struct protid *diruser,
+		    char *filename,
+		    int flags,
+		    mode_t mode,
+		    retry_type *do_retry,
+		    char *retry_name,
+		    mach_port_t *retry_port,
+		    mach_msg_type_name_t *retry_port_type)
+{
+  int create;			/* true if O_CREAT flag set */
+  int excl;			/* true if O_EXCL flag set */
+  int mustbedir = 0;		/* true if the result must be S_IFDIR */
+  int lastcomp = 0;		/* true if we are at the last component */
+  int newnode = 0;		/* true if this node is newly created */
+  int nsymlinks = 0;
+  struct node *dnp, *np;
+  char *nextname;
+  error_t error = 0;
+  struct protid *newpi;
+  struct iouser *user;
+
+  if (!diruser)
+    return EOPNOTSUPP;
+
+  create = (flags & O_CREAT);
+  excl = (flags & O_EXCL);
+
+  /* Skip leading slashes */
+  while (*filename == '/')
+    filename++;
+
+  *retry_port_type = MACH_MSG_TYPE_MAKE_SEND;
+  *do_retry = FS_RETRY_NORMAL;
+  *retry_name = '\0';
+
+  if (*filename == '\0')
+    {
+      /* Set things up in the state expected by the code from gotit: on. */
+      dnp = 0;
+      np = diruser->po->np;
+      mutex_lock (&np->lock);
+      netfs_nref (np);
+      goto gotit;
+    }
+
+  dnp = diruser->po->np;
+
+  mutex_lock (&dnp->lock);
+
+  netfs_nref (dnp);		/* acquire a reference for later netfs_nput */
+
+  do
+    {
+      assert (!lastcomp);
+
+      /* Find the name of the next pathname component */
+      nextname = index (filename, '/');
+
+      if (nextname)
+	{
+	  *nextname++ = '\0';
+	  while (*nextname == '/')
+	    nextname++;
+	  if (*nextname == '\0')
+	    {
+	      /* These are the rules for filenames ending in /. */
+	      nextname = 0;
+	      lastcomp = 1;
+	      mustbedir = 1;
+	      create = 0;
+	    }
+	  else
+	    lastcomp = 0;
+	}
+      else
+	lastcomp = 1;
+
+      np = 0;
+
+    retry_lookup:
+
+      if ((dnp == netfs_root_node || dnp == diruser->po->shadow_root)
+	  && filename[0] == '.' && filename[1] == '.' && filename[2] == '\0')
+	if (dnp == diruser->po->shadow_root)
+	  /* We're at the root of a shadow tree.  */
+	  {
+	    *do_retry = FS_RETRY_REAUTH;
+	    *retry_port = diruser->po->shadow_root_parent;
+	    *retry_port_type = MACH_MSG_TYPE_COPY_SEND;
+	    if (! lastcomp)
+	      strcpy (retry_name, nextname);
+	    error = 0;
+	    mutex_unlock (&dnp->lock);
+	    goto out;
+	  }
+	else if (diruser->po->root_parent != MACH_PORT_NULL)
+	  /* We're at a real translator root; even if DIRUSER->po has a
+	     shadow root, we can get here if its in a directory that was
+	     renamed out from under it...  */
+	  {
+	    *do_retry = FS_RETRY_REAUTH;
+	    *retry_port = diruser->po->root_parent;
+	    *retry_port_type = MACH_MSG_TYPE_COPY_SEND;
+	    if (!lastcomp)
+	      strcpy (retry_name, nextname);
+	    error = 0;
+	    mutex_unlock (&dnp->lock);
+	    goto out;
+	  }
+	else
+	  /* We are global root */
+	  {
+	    error = 0;
+	    np = dnp;
+	    netfs_nref (np);
+	  }
+      else
+	/* Attempt a lookup on the next pathname component. */
+	error = netfs_attempt_lookup_improved (diruser->user, dnp,
+					       filename, &np, 
+					       flags, lastcomp,
+					       retry_port, retry_port_type);
+      
+      /* At this point, DNP is unlocked */
+      
+      /* Implement O_EXCL flag here */
+      if (lastcomp && create && excl && !error && np)
+	error = EEXIST;
+      
+      /* Create the new node if necessary */
+      if (lastcomp && create && error == ENOENT)
+	{
+	  mode &= ~(S_IFMT | S_ISPARE | S_ISVTX);
+	  mode |= S_IFREG;
+	  mutex_lock (&dnp->lock);
+
+	  error = netfs_attempt_create_file_reduced (diruser->user, dnp,
+						     filename, mode, flags);
+
+	  /* We retry lookup in two cases:
+	     - we created the file and we have to get a valid port;
+	     - someone has already created the file (between our lookup
+	     and this create) then we just got EEXIST.  If we are EXCL, 
+	     that's fine; otherwise, we have to retry the lookup.  */
+	    if ((!error) || (error == EEXIST && !excl))
+	    {
+	      mutex_lock (&dnp->lock);
+	      goto retry_lookup;
+	    }
+	  
+	  newnode = 1;
+	}
+
+      /* All remaining errors get returned to the user */
+      if (error)
+	goto out;
+
+      if (np)
+	{
+	  mutex_lock (&np->lock);
+	  error = netfs_validate_stat (np, diruser->user);
+	  mutex_unlock (&np->lock);
+	  if (error)
+	    goto out;
+	}
+
+      if (np
+	  && S_ISLNK (np->nn_translated)
+	  && (!lastcomp
+	      || mustbedir	/* "foo/" must see that foo points to a dir */
+	      || !(flags & (O_NOLINK|O_NOTRANS))))
+	{
+	  size_t nextnamelen, newnamelen, linklen;
+	  char *linkbuf;
+
+	  /* Handle symlink interpretation */
+	  if (nsymlinks++ > netfs_maxsymlinks)
+	    {
+	      error = ELOOP;
+	      goto out;
+	    }
+
+	  linklen = np->nn_stat.st_size;
+
+	  nextnamelen = nextname ? strlen (nextname) + 1 : 0;
+	  newnamelen = nextnamelen + linklen + 1;
+	  linkbuf = alloca (newnamelen);
+
+	  error = netfs_attempt_readlink (diruser->user, np, linkbuf);
+	  if (error)
+	    goto out;
+
+	  if (nextname)
+	    {
+	      linkbuf[linklen] = '/';
+	      memcpy (linkbuf + linklen + 1, nextname,
+		     nextnamelen - 1);
+	    }
+	  linkbuf[nextnamelen + linklen] = '\0';
+
+	  if (linkbuf[0] == '/')
+	    {
+	      /* Punt to the caller */
+	      *do_retry = FS_RETRY_MAGICAL;
+	      *retry_port = MACH_PORT_NULL;
+	      strcpy (retry_name, linkbuf);
+	      goto out;
+	    }
+
+	  filename = linkbuf;
+	  if (lastcomp)
+	    {
+	      lastcomp = 0;
+
+	      /* Symlinks to nonexistent files aren't allowed to cause
+		 creation, so clear the flag here. */
+	      create = 0;
+	    }
+	  netfs_nput (np);
+	  mutex_lock (&dnp->lock);
+	  np = 0;
+	}
+      else
+	{
+	  /* Normal nodes here for next filename component */
+	  filename = nextname;
+	  netfs_nrele (dnp);
+
+	  if (lastcomp)
+	    dnp = 0;
+	  else
+	    {
+	      dnp = np;
+	      np = 0;
+	    }
+	}
+    }
+  while (filename && *filename);
+
+  /* At this point, NP is the node to return.  */
+ gotit:
+
+  if (mustbedir && ! np)
+    {
+      error = ENOTDIR;
+      goto out;
+    }
+
+  if (np)
+    error = netfs_check_open_permissions (diruser->user, np,
+					  flags, newnode);
+      
+  if (error)
+    goto out;
+
+  flags &= ~OPENONLY_STATE_MODES;
+
+  if (np)
+    {
+      error = iohelp_dup_iouser (&user, diruser->user);
+      if (error)
+	goto out;
+
+      newpi = netfs_make_protid (netfs_make_peropen (np, flags, diruser->po),
+				 user);
+      if (! newpi)
+	{
+	  iohelp_free_iouser (user);
+	  error = errno;
+	  goto out;
+	}
+
+      *retry_port = ports_get_right (newpi);
+      ports_port_deref (newpi);
+    }
+
+ out:
+  if (np)
+    netfs_nput (np);
+  if (dnp)
+    netfs_nrele (dnp);
+  return error;
+}
+
+/* Fill the array *DATA of size BUFSIZE with up to NENTRIES dirents
+   from DIR (which is locked) starting with entry ENTRY for user CRED.
+   The number of entries in the array is stored in *AMT and the number
+   of bytes in *DATACNT.  If the supplied buffer is not large enough
+   to hold the data, it should be grown.  */
+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)
+{
+  node_dirent_t *dirent_start, *dirent_current;
+  node_dirent_t *dirent_list = NULL;
+  size_t size = 0;
+  int count = 0;
+  char *data_p;
+  error_t err;
+
+  int bump_size (const char *name)
+    {
+      if (num_entries == -1 || count < num_entries)
+	{
+	  size_t new_size = size + DIRENT_LEN (strlen (name));
+
+	  if (max_data_len > 0 && new_size > max_data_len)
+	    return 0;
+	  size = new_size;
+	  count++;
+	  return 1;
+	}
+      else
+	return 0;
+    }
+
+  int add_dirent (const char *name, ino_t fileno, int type)
+    {
+      if (num_entries == -1 || count < num_entries)
+	{
+	  struct dirent hdr;
+	  size_t name_len = strlen (name);
+	  size_t sz = DIRENT_LEN (name_len);
+
+	  if (sz > size)
+	    return 0;
+	  else
+	    size -= sz;
+	  
+	  hdr.d_fileno = fileno;
+	  hdr.d_reclen = sz;
+	  hdr.d_type = type;
+	  hdr.d_namlen = name_len;
+
+	  memcpy (data_p, &hdr, DIRENT_NAME_OFFS);
+	  strcpy (data_p + DIRENT_NAME_OFFS, name);
+	  data_p += sz;
+	  count++;
+
+	  return 1;
+	}
+      else
+	return 0;
+    }
+
+  err = node_entries_get (dir, &dirent_list);
+
+  if (! err)
+    {
+      for (dirent_start = dirent_list, count = 2;
+	   dirent_start && first_entry > count;
+	   dirent_start = dirent_start->next, count++);
+
+      count = 0;
+
+      /* Make space for the `.' and `..' entries.  */
+      if (first_entry == 0)
+	bump_size (".");
+      if (first_entry <= 1)
+	bump_size ("..");
+
+      /* See how much space we need for the result.  */
+      for (dirent_current = dirent_start;
+	   dirent_current;
+	   dirent_current = dirent_current->next)
+	if (! bump_size (dirent_current->dirent->d_name))
+	  break;
+
+      *data = mmap (0, size, PROT_READ|PROT_WRITE, MAP_ANON, 0, 0);
+      err = ((void *) *data == (void *) -1) ? errno : 0;
+    }
+
+  if (! err)
+    {
+      data_p = *data;
+      *data_len = size;
+      *data_entries = count;
+      count = 0;
+
+      /* Add `.' and `..' entries.  */
+      if (first_entry == 0)
+	add_dirent (".", 2, DT_DIR);
+      if (first_entry <= 1)
+	add_dirent ("..", 2, DT_DIR);
+
+      for (dirent_current = dirent_start;
+	   dirent_current;
+	   dirent_current = dirent_current->next)
+	if (! add_dirent (dirent_current->dirent->d_name,
+			  2	/* FIXME */,
+			  dirent_current->dirent->d_type))
+	  break;
+    }
+
+  if (dirent_list)
+    node_entries_free (dirent_list);
+
+  fshelp_touch (&dir->nn_stat, TOUCH_ATIME, maptime);
+
+  return err;
+}
diff --git a/unionfs/netfs.o b/unionfs/netfs.o
new file mode 100644
index 00000000..25412efd
--- /dev/null
+++ b/unionfs/netfs.o
diff --git a/unionfs/node.c b/unionfs/node.c
new file mode 100644
index 00000000..cf9a8b47
--- /dev/null
+++ b/unionfs/node.c
@@ -0,0 +1,555 @@
+/* Hurd unionfs
+   Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
+   Written by Moritz Schulte <moritz@duesseldorf.ccc.de>.
+
+   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.  */
+
+/* node management.  */
+
+#define _GNU_SOURCE
+
+#include <hurd/netfs.h>
+#include <stdlib.h>
+#include <error.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <stdio.h>
+
+#include "unionfs.h"
+#include "node.h"
+#include "ulfs.h"
+#include "lib.h"
+
+/* Declarations for functions only used in this file.  */
+
+/* Deallocate all ports contained in NODE and free per-ulfs data
+   structures.  */
+void node_ulfs_free (node_t *node);
+
+/* Create a new node, derived from a light node, add a reference to
+   the light node.  */
+error_t
+node_create (lnode_t *lnode, node_t **node)
+{
+  netnode_t *netnode_new = malloc (sizeof (netnode_t));
+  error_t err = 0;
+  node_t *node_new;
+
+  debug_msg ("node_create for lnode: %s", lnode->name);
+
+  if (! netnode_new)
+    {
+      err = ENOMEM;
+      return err;
+    }
+
+  node_new = netfs_make_node (netnode_new);
+  if (! node_new)
+    {
+      err = ENOMEM;
+      free (netnode_new);
+      return err;
+    }
+
+  node_new->nn->ulfs = NULL;
+
+  err = node_ulfs_init (node_new);
+  if (err)
+    {
+      node_destroy (node_new);
+      return err;
+    }
+
+  lnode->node = node_new;
+  lnode_ref_add (lnode);
+  node_new->nn->lnode = lnode;
+  node_new->nn->flags = 0;
+  node_new->nn->ncache_next = NULL;
+  node_new->nn->ncache_prev = NULL;
+  *node = node_new;
+
+  return err;
+}
+
+/* Destroy a node, remove one reference from the associated light
+   node.  */
+void
+node_destroy (node_t *node)
+{
+  debug_msg ("node destroy: %s", node->nn->lnode->name);
+  assert (! (node->nn->ncache_next || node->nn->ncache_prev));
+  node_ulfs_free (node);
+  mutex_lock (&node->nn->lnode->lock);
+  node->nn->lnode->node = NULL;
+  lnode_ref_remove (node->nn->lnode);
+  free (node->nn);
+  free (node);
+}
+
+/* Make sure that all ports to the underlying filesystems of NODE,
+   which must be locked, are uptodate.  */
+error_t
+node_update (node_t *node)
+{
+  error_t err = 0;
+  char *path;
+
+  node_ulfs_t *root_ulfs;
+  struct stat stat;
+  file_t port;
+  int i = 0;
+  
+  debug_msg ("node_update for lnode: %s", node->nn->lnode->name);
+
+  if (node_is_root (node))
+    return err;
+
+  mutex_lock (&netfs_root_node->lock);
+
+  err = lnode_path_construct (node->nn->lnode, &path);
+  if (err)
+    {
+      mutex_unlock (&netfs_root_node->lock);
+      return err;
+    }
+
+  root_ulfs = netfs_root_node->nn->ulfs;
+
+  node_ulfs_iterate_unlocked (node)
+    {
+  
+      if (node_ulfs->flags & FLAG_NODE_ULFS_FIXED)
+	{
+	  i++;
+	  continue;
+	}
+      
+      /* We really have to update the port.  */
+      if (port_valid (node_ulfs->port))
+	port_dealloc (node_ulfs->port);
+
+      err = file_lookup ((root_ulfs + i)->port, path,
+			 O_READ | O_NOTRANS, O_NOTRANS,
+			 0, &port, &stat);
+      
+      if (err)
+	{
+	  node_ulfs->port = MACH_PORT_NULL;
+	  err = 0;
+	  i++;
+	  continue;
+	}
+      
+      if (stat.st_ino == underlying_node_stat.st_ino
+	  && stat.st_fsid == underlying_node_stat.st_fsid)
+	/* It's OUR root node.  */
+	err = ELOOP;
+      else
+	{
+	  port_dealloc (port);
+	  err = file_lookup ((root_ulfs + i)->port, path,
+			     O_READ, 0, 0, &port, &stat);
+	}
+      
+      if (err)
+	{
+	  port = MACH_PORT_NULL;
+	  err = 0;
+	}
+      node_ulfs->port = port;
+      
+      i++;
+    }
+
+  free (path);
+  node->nn->flags |= FLAG_NODE_ULFS_UPTODATE;
+
+  mutex_unlock (&netfs_root_node->lock);
+  
+  return err;
+}
+
+/* Remove all directory named NAME beneath DIR on all underlying filesystems.
+   Fails if we cannot remove all the directories.  */
+error_t
+node_dir_remove (node_t *dir, char *name)
+{
+  error_t err = 0;
+
+  node_ulfs_iterate_reverse_unlocked (dir)
+    {
+      if (!port_valid (node_ulfs->port))
+	continue;
+
+      err = dir_rmdir (node_ulfs->port, name);
+      if ((err) && (err != ENOENT))
+	break;
+    }
+
+  return err;
+}
+
+/* Create a directory named NAME beneath DIR on the first (writable) underlying
+   filesystem.  */
+error_t
+node_dir_create (node_t *dir, char *name, mode_t mode)
+{
+  error_t err = 0;
+
+  node_ulfs_iterate_unlocked (dir)
+    {
+      if (!port_valid (node_ulfs->port))
+	continue;
+      
+      err = dir_mkdir (node_ulfs->port, name, mode);
+
+      if ((!err) || (err == EEXIST) || (err == ENOTDIR))
+	break;
+    }
+  
+  return err;
+}
+
+/* Remove all files named NAME beneath DIR on the underlying filesystems
+   with FLAGS as openflags.  */
+error_t
+node_unlink_file (node_t *dir, char *name)
+{
+  mach_port_t p;
+  struct stat stat;
+  error_t err = 0;
+  int removed = 0;
+
+  /* Using reverse iteration still have issues. Infact, we could be
+     deleting a file in some underlying filesystem, and keeping those
+     after the first occurring error. 
+     FIXME: Check BEFORE starting deletion.  */
+     
+  node_ulfs_iterate_reverse_unlocked (dir)
+    {
+      
+      if (!port_valid (node_ulfs->port))
+	continue;
+      
+      err = file_lookup (node_ulfs->port, name,
+			 O_NOTRANS, O_NOTRANS,
+			 0, &p, &stat);
+
+      port_dealloc (p);
+
+      if (err == ENOENT)
+	{
+	  err = 0;
+	  continue;
+	}
+      
+      if (err)
+	break;
+      
+      err = dir_unlink (node_ulfs->port, name);
+      if ((err) && (err != ENOENT))
+	break;
+
+      if (!err)
+	removed++;
+
+    }
+
+  if ((!err) && (!removed))
+    err = ENOENT;
+
+  return err;
+}
+
+/* Lookup a file named NAME beneath DIR on the underlying filesystems
+   with FLAGS as openflags.  Return the first port successfully looked
+   up in *PORT and according stat information in *STAT.  */
+error_t
+node_lookup_file (node_t *dir, char *name, int flags,
+		  file_t *port, struct stat *s)
+{
+  error_t err = ENOENT;
+  struct stat stat;
+  file_t p;
+
+  node_ulfs_iterate_unlocked (dir)
+    {
+
+      if (err != ENOENT)
+	break;
+
+      if (!port_valid (node_ulfs->port))
+	continue;
+
+      err = file_lookup (node_ulfs->port, name,
+			 flags | O_NOTRANS, O_NOTRANS,
+			 0, &p, &stat);
+      if (err)
+	continue;
+
+      if (stat.st_ino == underlying_node_stat.st_ino
+	  && stat.st_fsid == underlying_node_stat.st_fsid)
+	/* It's OUR root node.  */
+	err = ELOOP;
+      else 
+	/* stat.st_mode & S_ITRANS  */
+	{
+	  port_dealloc (p);
+	  err = file_lookup (node_ulfs->port, name,
+			     flags, 0, 0, &p, &stat);
+	}
+    }
+
+  if (! err)
+    {
+      *s = stat;
+      *port = p;
+    }
+
+  return err;
+}
+
+/* Deallocate all ports contained in NODE and free per-ulfs data
+   structures.  */
+void
+node_ulfs_free (node_t *node)
+{
+
+  node_ulfs_iterate_unlocked (node)
+    {
+      if (port_valid (node_ulfs->port)
+	  && node_ulfs->port != underlying_node)
+	port_dealloc (node_ulfs->port);
+    }
+
+  free (node->nn->ulfs);
+}
+
+/* Initialize per-ulfs data structures for NODE.  The ulfs_lock must
+   be held by the caller.  */
+error_t
+node_ulfs_init (node_t *node)
+{
+  node_ulfs_t *ulfs_new;
+  error_t err = 0;
+  
+  ulfs_new = malloc (ulfs_num * sizeof (node_ulfs_t));
+  if (! ulfs_new)
+    {
+      err = ENOMEM;
+      return err;
+    }
+
+  if (node->nn->ulfs)
+    node_ulfs_free (node);
+
+  node->nn->ulfs = ulfs_new;
+  node->nn->ulfs_num = ulfs_num;
+      
+  node_ulfs_iterate_unlocked (node)
+    {
+      node_ulfs->flags = 0;
+      node_ulfs->port = port_null;
+    }
+
+  return err;
+}
+
+/* Read the merged directory entries from NODE, which must be
+   locked, into *DIRENTS.  */
+error_t
+node_entries_get (node_t *node, node_dirent_t **dirents)
+{
+  struct dirent **dirent_list, **dirent;
+  node_dirent_t *node_dirent_list = NULL;
+  size_t dirent_data_size;
+  char *dirent_data;
+  error_t err = 0;
+
+  /* Add a dirent to the list.  If an entry with the specified name
+     already exists, reuse that entry.  Otherwise create a new
+     one.  */
+  error_t node_dirent_add (char *name, ino_t fileno, int type)
+    {
+      error_t e = 0;
+      node_dirent_t *node_dirent;
+      node_dirent_t *node_dirent_new;
+      struct dirent *dirent_new;
+      int name_len = strlen (name);
+      int size = DIRENT_LEN (name_len);
+
+
+      for (node_dirent = node_dirent_list;
+	   node_dirent && strcmp (node_dirent->dirent->d_name, name);
+	   node_dirent = node_dirent->next);
+
+      if (node_dirent)
+	{
+	  /* Reuse existing entry.  */
+
+	  node_dirent->dirent->d_fileno = fileno;
+	  node_dirent->dirent->d_type = type;
+	  return e;
+	}
+
+      /* Create new entry.  */
+      
+      node_dirent_new = malloc (sizeof (node_dirent_t));
+      if (!node_dirent_new)
+	{
+	  e = ENOMEM;
+	  return e;
+	}
+
+      dirent_new = malloc (size);
+      if (!dirent_new)
+	{
+	  free (node_dirent_new);
+	  e = ENOMEM;
+	  return e;
+	}
+
+      /* Fill dirent.  */
+      dirent_new->d_fileno = fileno;
+      dirent_new->d_type = type;
+      dirent_new->d_reclen = size;
+      strcpy ((char *) dirent_new + DIRENT_NAME_OFFS, name);
+      
+      /* Add dirent to the list.  */
+      node_dirent_new->dirent = dirent_new;
+      node_dirent_new->next = node_dirent_list;
+      node_dirent_list = node_dirent_new;
+      
+      return e;
+    }
+
+  node_ulfs_iterate_unlocked(node)
+    {
+      if (!port_valid (node_ulfs->port))
+	continue;
+
+      err = dir_entries_get (node_ulfs->port, &dirent_data,
+			     &dirent_data_size, &dirent_list);
+      if (err)
+	continue;
+      
+      for (dirent = dirent_list; (! err) && *dirent; dirent++)
+	if (strcmp ((*dirent)->d_name, ".")
+	    && strcmp ((*dirent)->d_name, ".."))
+	  err = node_dirent_add ((*dirent)->d_name,
+				 (*dirent)->d_fileno,
+				 (*dirent)->d_type);
+
+      free (dirent_list);
+      munmap (dirent_data, dirent_data_size);
+    }
+
+  if (err)
+    node_entries_free (node_dirent_list);
+  else
+    *dirents = node_dirent_list;
+
+  return err;
+}
+
+/* Free DIRENTS.  */
+void
+node_entries_free (node_dirent_t *dirents)
+{
+  node_dirent_t *dirent, *dirent_next;
+
+  for (dirent = dirents; dirent; dirent = dirent_next)
+    {
+      dirent_next = dirent->next;
+      free (dirent->dirent);
+      free (dirent);
+    }
+}
+
+/* Create the root node (and it's according lnode) and store it in
+   *ROOT_NODE.  */
+error_t
+node_create_root (node_t **root_node)
+{
+  lnode_t *lnode;
+  node_t *node;
+  error_t err = 0;
+
+  err = lnode_create (NULL, &lnode);
+  if (err)
+    return err;
+
+  err = node_create (lnode, &node);
+  if (err)
+    {
+      lnode_destroy (lnode);
+      return err;
+    }
+
+  mutex_unlock (&lnode->lock);
+  *root_node = node;
+  return err;
+}
+
+/* Initialize the ports to the underlying filesystems for the root
+   node.  */
+
+error_t
+node_init_root (node_t *node)
+{
+  error_t err;
+  ulfs_t *ulfs;
+  int i = 0;
+
+  mutex_lock (&ulfs_lock);
+
+  err = node_ulfs_init (node);
+  if (err)
+    {
+      mutex_unlock (&ulfs_lock);
+      return err;
+    }
+
+  node_ulfs_iterate_unlocked (node)
+    {
+
+      if (err)
+	break;
+
+      err = ulfs_get_num (i, &ulfs);
+      if (err)
+	  break;
+
+      if (ulfs->path)
+	node_ulfs->port = file_name_lookup (ulfs->path,
+					    O_READ | O_DIRECTORY, 0);
+      else
+	node_ulfs->port = underlying_node;
+	  
+      if (! port_valid (node_ulfs->port))
+	{
+	  err = errno;
+	  break;
+	}
+
+      node_ulfs->flags |= FLAG_NODE_ULFS_FIXED;
+      i++;
+    }
+
+  mutex_unlock (&ulfs_lock);
+  return err;
+}
diff --git a/unionfs/node.h b/unionfs/node.h
new file mode 100644
index 00000000..41ae43ad
--- /dev/null
+++ b/unionfs/node.h
@@ -0,0 +1,135 @@
+/* Hurd unionfs
+   Copyright (C) 2001, 2002 Free Software Foundation, Inc.
+   Written by Moritz Schulte <moritz@duesseldorf.ccc.de>.
+
+   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.  */
+
+/* node management.  */
+
+#ifndef INCLUDED_NODE_H
+#define INCLUDED_NODE_H
+
+#include <error.h>
+#include <sys/stat.h>
+#include <hurd/netfs.h>
+
+typedef struct node node_t;
+
+#include "lnode.h"
+
+/* per-ulfs data for each node.  */
+struct node_ulfs
+{
+  int flags;			/* Flags associated for this
+				   underlying filesystem.  */
+  file_t port;			/* A port to the underlying
+				   filesystem.  */
+};
+typedef struct node_ulfs node_ulfs_t;
+
+/* Flags.  */
+
+/* The according port should not be updated.  */
+#define FLAG_NODE_ULFS_FIXED 0x00000001
+
+struct netnode
+{
+  lnode_t *lnode;		/* A reference to the according light
+				   node.  */
+  int flags;			/* Associated flags.  */
+  node_ulfs_t *ulfs;		/* Array holding data for each
+				   underlying filesystem.  */
+  int ulfs_num;			/* Number of entries in ULFS.  */
+  node_t *ncache_next;
+  node_t *ncache_prev;
+};
+typedef struct netnode netnode_t;
+
+/* Flags.  */
+#define FLAG_NODE_INVALIDATE    0x00000001
+#define FLAG_NODE_ULFS_UPTODATE 0x00000002
+
+typedef struct node_dirent
+{
+  struct dirent *dirent;
+  struct node_dirent *next;
+} node_dirent_t;
+
+/* Create a new node, derived from a light node, add a reference to
+   the light node.  */
+error_t node_create (lnode_t *lnode, node_t **node);
+
+/* Destroy a node, remove one reference from the associated light
+   node.  */
+void node_destroy (node_t *node);
+
+/* Make sure that all ports to the underlying filesystems of NODE,
+   which must be locked, are uptodate.  */
+error_t node_update (node_t *node);
+
+/* Create a directory named NAME beneath DIR on all the (writable) underlying
+   filesystems.  */
+error_t node_dir_create (node_t *dir, char *name, mode_t mode);
+
+/* Remove all directory named NAME beneath DIR on all underlying filesystems.
+   Fails if we cannot remove all the directories.  */
+error_t node_dir_remove (node_t *dir, char *name);
+
+/* Remove all files named NAME beneath DIR on the underlying filesystems
+   with FLAGS as openflags.  */
+error_t node_unlink_file (node_t *dir, char *name);
+
+/* Lookup a file named NAME beneath DIR on the underlying filesystems
+   with FLAGS as openflags.  Return the first port successfully looked
+   up in *PORT and according stat information in *STAT.  */
+error_t node_lookup_file (node_t *dir, char *name, int flags,
+			  file_t *port, struct stat *stat);
+
+/* Initialize per-ulfs data structures for NODE.  The ulfs_lock must
+   be held by the caller.  */
+error_t node_ulfs_init (node_t *node);
+
+/* Read the merged directory entries from NODE, which must be
+   locked, into *DIRENTS.  */
+error_t node_entries_get (node_t *node, node_dirent_t **dirents);
+
+/* Free DIRENTS.  */
+void node_entries_free (node_dirent_t *dirents);
+
+/* Create the root node (and it's according lnode) and store it in
+   *ROOT_NODE.  */
+error_t node_create_root (node_t **root_node);
+
+/* Initialize the ports to the underlying filesystems for the root
+   node.  */
+error_t node_init_root (node_t *node);
+
+/* Return non-zero, if NODE is the root node.  */
+#define node_is_root(node) (node)->nn->lnode->dir ? 0 : 1
+
+/* Iterate over the per-ulfs data in NODE, which must be locked by the
+   caller.  */
+#define node_ulfs_iterate_unlocked(node)              \
+  for (node_ulfs_t *node_ulfs = (node)->nn->ulfs;     \
+       node_ulfs < (node)->nn->ulfs + (node)->nn->ulfs_num;  \
+       node_ulfs++)
+
+#define node_ulfs_iterate_reverse_unlocked(node)			\
+  for (node_ulfs_t *node_ulfs = (node)->nn->ulfs + (node)->nn->ulfs_num - 1;\
+       node_ulfs >= (node)->nn->ulfs;					\
+       node_ulfs--)
+
+#endif
diff --git a/unionfs/node.o b/unionfs/node.o
new file mode 100644
index 00000000..b443a676
--- /dev/null
+++ b/unionfs/node.o
diff --git a/unionfs/options.c b/unionfs/options.c
new file mode 100644
index 00000000..ef29a020
--- /dev/null
+++ b/unionfs/options.c
@@ -0,0 +1,225 @@
+/* Hurd unionfs
+   Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
+   Written by Moritz Schulte <moritz@duesseldorf.ccc.de>.
+
+   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.  */
+
+/* Argument parsing.  */
+
+#define _GNU_SOURCE
+
+#include <argp.h>
+#include <error.h>
+
+#include "options.h"
+#include "ulfs.h"
+#include "ncache.h"
+#include "unionfs.h"
+#include "node.h"
+#include "version.h"
+#include "pattern.h"
+#include "stow.h"
+#include "update.h"
+
+/* This variable is set to a non-zero value after parsing of the
+   startup options.  Whenever the argument parser is later called to
+   modify the underlying filesystems of the root node, the root node
+   is initialized accordingly directly by the parser.  */
+static int parsing_startup_options_finished;
+
+/* Argp options common to the runtime and startup parser.  */
+static const struct argp_option argp_common_options[] =
+  {
+    { OPT_LONG_UNDERLYING, OPT_UNDERLYING, 0, 0,
+      "add the underlying node to the unionfs" },
+    { OPT_LONG_WRITABLE, OPT_WRITABLE, 0, 0,
+      "specify the following filesystem as writable" },
+    { OPT_LONG_DEBUG, OPT_DEBUG, 0, OPTION_HIDDEN,
+      "send debugging messages to stderr" },
+    { OPT_LONG_CACHE_SIZE, OPT_CACHE_SIZE, "SIZE", 0,
+      "specify the maximum number of nodes in the cache" },
+    { 0, 0, 0, 0, "Runtime options:", 1 },
+    { OPT_LONG_STOW, OPT_STOW, "STOWDIR", 0,
+      "stow given directory", 1},
+    { OPT_LONG_PRIORITY, OPT_PRIORITY, "VALUE", 0,
+      "Set the priority for the following filesystem to VALUE", 1},
+    { OPT_LONG_PATTERN, OPT_PATTERN, "PATTERN", 0,
+      "add only nodes of the underlying filesystem matching pattern", 1},
+    { OPT_LONG_REMOVE, OPT_REMOVE, 0, 0,
+      "remove the following filesystem", 1 },
+    { OPT_LONG_ADD, OPT_ADD, 0, 0,
+      "add the following filesystem (Default)", 1 },
+    { 0 }
+  };
+
+/* Argp options only meaningful for startup parsing.  */
+static const struct argp_option argp_startup_options[] =
+  {
+    { 0 }
+  };
+
+/* Argp parser function for the common options.  */
+static error_t
+argp_parse_common_options (int key, char *arg, struct argp_state *state)
+{
+  static int ulfs_flags = 0, ulfs_mode = 0, ulfs_modified = 0,
+    ulfs_match = 0, ulfs_priority = 0;
+  static struct patternlist ulfs_patternlist =
+    {    
+      .lock = MUTEX_INITIALIZER,
+      .head = NULL
+    };
+  error_t err = 0;
+
+  switch (key)
+    {
+    case OPT_WRITABLE:		/* --writable  */
+      ulfs_flags |= FLAG_ULFS_WRITABLE;
+      break;
+
+    case OPT_PRIORITY:		/* --priority */
+      ulfs_priority = strtol (arg, NULL, 10);
+      break;
+
+    case OPT_DEBUG:		/* --debug  */
+      unionfs_flags |= FLAG_UNIONFS_MODE_DEBUG;
+      break;
+
+    case OPT_CACHE_SIZE:	/* --cache-size  */
+      ncache_size = strtol (arg, NULL, 10);
+      break;
+
+    case OPT_ADD:		/* --add */
+      ulfs_mode = ULFS_MODE_ADD;
+      break;
+
+    case OPT_REMOVE:		/* --remove  */
+      ulfs_mode = ULFS_MODE_REMOVE;
+      break;
+
+    case OPT_PATTERN:           /* --match  */
+      ulfs_match = 1;
+      patternlist_add (&ulfs_patternlist, arg);
+      break;
+
+    case OPT_STOW:		/* --stow */
+      err = stow_diradd (arg, ulfs_flags, &ulfs_patternlist, ulfs_priority);
+      if (err)
+	error (EXIT_FAILURE, err, "stow_diradd");
+      ulfs_modified = 1;
+      ulfs_flags = ulfs_mode = ulfs_priority = 0;
+      ulfs_match = 0;
+      break;
+
+    case OPT_UNDERLYING:	/* --underlying  */
+    case ARGP_KEY_ARG:
+
+      if (ulfs_mode == ULFS_MODE_REMOVE)
+	{
+	  err = ulfs_unregister (arg);
+	  if (err == ENOENT)
+	    /* It is not a fatal error, when the user tries to remove
+	       a filesystem, which is not used by unionfs.  */
+	    err = 0;
+	}
+      else
+	err = ulfs_register (arg, ulfs_flags, ulfs_priority);
+      if (err)
+	error (EXIT_FAILURE, err, "ulfs_register");
+      ulfs_modified = 1;
+      ulfs_flags = ulfs_mode = ulfs_priority = 0;
+      ulfs_match = 0;
+      break;
+
+    case ARGP_KEY_END:
+      ulfs_flags = ulfs_mode = 0;
+      if (ulfs_modified && parsing_startup_options_finished)
+	{
+	  root_update_schedule ();
+	}
+      else
+	{
+	  ncache_reset ();
+	}
+      ulfs_modified = 0;
+
+      if (! parsing_startup_options_finished)
+	parsing_startup_options_finished = 1;
+      break;
+
+    default:
+      err = ARGP_ERR_UNKNOWN;
+      break;
+    }
+
+  return err;
+}
+
+/* Argp parser function for the startup oprtions.  */
+static error_t
+argp_parse_startup_options (int key, char *arg, struct argp_state *state)
+{
+  error_t err = 0;
+
+  switch (key)
+    {
+    default:
+      err = ARGP_ERR_UNKNOWN;
+      break;
+    }
+  
+  return err;
+}
+
+/* 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 struct argp argp_parser_startup_options =
+  { argp_startup_options, argp_parse_startup_options, 0, 0, 0 };
+
+/* The children parser for runtime arguments.  */
+static const struct argp_child argp_children_runtime[] =
+  {
+    { &argp_parser_common_options },
+    { &netfs_std_runtime_argp },
+    { 0 }
+  };
+
+/* The children parser for startup arguments.  */
+const struct argp_child argp_children_startup[] =
+  {
+    { &argp_parser_startup_options },
+    { &argp_parser_common_options },
+    { &netfs_std_startup_argp },
+    { 0 }
+  };
+
+const char *argp_program_version = STANDARD_HURD_VERSION (unionfs);
+const char *argp_program_bug_address = 
+"Gianluca Guida <glguida@gmail.com>";
+
+#define ARGS_DOC "FILESYSTEMS ..."
+#define DOC      "Hurd unionfs server"
+
+/* The final argp parser for runtime arguments.  */
+struct argp argp_runtime =
+  { 0, 0, 0, 0, argp_children_runtime };
+
+/* The final argp parser for startup arguments.  */
+struct argp argp_startup =
+  { 0, 0, ARGS_DOC, DOC, argp_children_startup };
diff --git a/unionfs/options.h b/unionfs/options.h
new file mode 100644
index 00000000..eb74ce61
--- /dev/null
+++ b/unionfs/options.h
@@ -0,0 +1,53 @@
+/* Hurd unionfs
+   Copyright (C) 2001, 2002 Free Software Foundation, Inc.
+   Written by Moritz Schulte <moritz@duesseldorf.ccc.de>.
+
+   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.  */
+
+/* Argument parsing.  */
+
+/* The possible short options.  */
+#define OPT_UNDERLYING 'u'
+#define OPT_WRITABLE   'w'
+#define OPT_DEBUG      'd'
+#define OPT_CACHE_SIZE 'c'
+#define OPT_REMOVE     'r'
+#define OPT_ADD        'a'
+#define OPT_PATTERN    'm'
+#define OPT_PRIORITY   'p'
+#define OPT_STOW       's'
+
+/* The long options.  */
+#define OPT_LONG_UNDERLYING "underlying"
+#define OPT_LONG_WRITABLE   "writable"
+#define OPT_LONG_DEBUG      "debug"
+#define OPT_LONG_CACHE_SIZE "cache-size"
+#define OPT_LONG_REMOVE     "remove"
+#define OPT_LONG_ADD        "add"
+#define OPT_LONG_PATTERN    "match"
+#define OPT_LONG_PRIORITY   "priority"
+#define OPT_LONG_STOW       "stow"
+
+#define OPT_LONG(o) "--" o
+
+/* The final argp parser for runtime arguments.  */
+extern struct argp argp_startup;
+
+/* The final argp parser for startup arguments.  */
+extern struct argp argp_runtime;
+
+#define ULFS_MODE_ADD    0
+#define ULFS_MODE_REMOVE 1
diff --git a/unionfs/options.o b/unionfs/options.o
new file mode 100644
index 00000000..b383a8f4
--- /dev/null
+++ b/unionfs/options.o
diff --git a/unionfs/pattern.c b/unionfs/pattern.c
new file mode 100644
index 00000000..68a07917
--- /dev/null
+++ b/unionfs/pattern.c
@@ -0,0 +1,131 @@
+/* Hurd unionfs
+   Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
+   Written by Gianluca Guida <glguida@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.  */
+
+/* Pattern list management.  */
+
+#define _GNU_SOURCE
+
+#include <hurd/netfs.h>
+#include <stdlib.h>
+#include <fnmatch.h>
+#include <errno.h>
+
+#include "pattern.h"
+
+/* Add a wildcard expression *PATTERN to **PATTERNLIST.  */
+error_t
+patternlist_add (struct patternlist *list, char *pattern)
+{
+  error_t err = 0;
+  struct pattern *listentry;
+  char *dup;
+
+  if (pattern == NULL) /* BUG.  */
+    err = EINVAL;
+  
+  if (err)
+    return err;
+
+  dup = strdup (pattern);
+  if (dup == NULL) 
+    err = ENOMEM;
+
+  if (err)
+      return err;
+
+  listentry = malloc (sizeof (struct pattern));
+  if (listentry == NULL) 
+    err = ENOMEM;
+
+  if (err)
+      return err;
+
+  listentry->pattern = dup;
+
+  mutex_lock (& (list->lock));
+  if (list->head == NULL) /* List is empty.  */
+    {
+      list->head = listentry;
+      listentry->next = NULL;
+    }
+  else
+    {
+      listentry->next = list->head;
+      list->head = listentry;
+    }
+  mutex_unlock (& (list->lock));
+
+  return err;
+}
+
+/* Check for match all pattern of the list *LIST, returning logical OR
+   of results.  */
+int
+patternlist_match (struct patternlist *list, char *string)
+{
+  struct pattern *ptr;
+  error_t err = ~0; /* Return false by default */
+
+  ptr = list->head;
+
+  mutex_lock (&list->lock);
+  while (ptr != NULL)
+    {
+      err = fnmatch (ptr->pattern, string, FNM_FILE_NAME);
+
+      if (!err) /* String matched.  */
+	break;
+
+      ptr = ptr->next;
+    }
+  mutex_unlock (&list->lock);
+
+  return err;
+}
+
+/* Free all resource used by *PATTERNLIST.  */
+void
+patternlist_destroy (struct patternlist *list)
+{
+  struct pattern *next, *ptr = list->head;
+
+  mutex_lock (& (list->lock));
+  while (ptr != NULL)
+    {
+      next = ptr->next;
+
+      free (ptr);
+
+      ptr = next;
+    }
+  mutex_unlock (& (list->lock));
+}
+
+/* Return nonzero if *PATTERNLIST is empty.  */
+int
+patternlist_isempty (struct patternlist *list)
+{
+  int ret;
+
+  mutex_lock (& (list->lock));
+  ret = (list->head == NULL);
+  mutex_unlock (& (list->lock));
+
+  return ret;
+}
diff --git a/unionfs/pattern.h b/unionfs/pattern.h
new file mode 100644
index 00000000..1bab9933
--- /dev/null
+++ b/unionfs/pattern.h
@@ -0,0 +1,53 @@
+/* Hurd unionfs
+   Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
+   Written by Gianluca Guida <glguida@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.  */
+
+/* Pattern list management.  */
+
+#ifndef _PATTERN_H
+#define _PATTERN_H
+
+#include <hurd/netfs.h> /* For mutex stuff.  */
+
+struct pattern
+{
+  char *pattern;
+
+  struct pattern *next;
+};
+
+struct patternlist
+{
+  struct mutex lock;
+  struct pattern *head;
+};
+
+/* Add a wildcard expression *PATTERN to **PATTERNLIST.  */
+extern error_t patternlist_add (struct patternlist *list, char *pattern);
+
+/* Check for match all pattern of the list *LIST, returning logical OR
+   of results.  */
+extern int patternlist_match (struct patternlist *list, char *string);
+
+/* Free all resource used by *PATTERNLIST */
+extern void patternlist_destroy (struct patternlist *list);
+
+/* Return nonzero if *PATTERNLIST is empty */
+extern int patternlist_isempty (struct patternlist *list);
+
+#endif /* _PATTERN_H */
diff --git a/unionfs/pattern.o b/unionfs/pattern.o
new file mode 100644
index 00000000..92a2a4cf
--- /dev/null
+++ b/unionfs/pattern.o
diff --git a/unionfs/stow-mutations.h b/unionfs/stow-mutations.h
new file mode 100644
index 00000000..d36280d2
--- /dev/null
+++ b/unionfs/stow-mutations.h
@@ -0,0 +1,27 @@
+/* stow-mutations.h - MIG mutations unionfs.
+   Copyright (C) 2005 Free Software Foundation, Inc.
+   Written by Gianluca Guida <glguida@gmail.com>.
+
+   This file is part of the GNU Hurd.
+
+   The GNU Hurd 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, or (at
+   your option) any later version.
+
+   The GNU Hurd 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, USA. */
+
+/* Only CPP macro definitions should go in this file. */
+
+#define FS_NOTIFY_INTRAN stow_notify_t begin_using_notify_port (fs_notify_t)
+#define FS_NOTIFY_DESTRUCTOR end_using_notify_port (stow_notify_t)
+
+#define FS_NOTIFY_IMPORTS import "stow-priv.h";
+
diff --git a/unionfs/stow-priv.h b/unionfs/stow-priv.h
new file mode 100644
index 00000000..2212ac98
--- /dev/null
+++ b/unionfs/stow-priv.h
@@ -0,0 +1,45 @@
+/* Hurd unionfs
+   Copyright (C) 2005 Free Software Foundation, Inc.
+   Written by Gianluca Guida <glguida@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 __STOW_PRIVDATA_H__
+#define __STOW_PRIVDATA_H__
+
+#include <hurd/ports.h>
+
+struct stow_notify
+{
+  struct port_info pi;
+
+  char *dir_name;
+  struct stow_privdata *priv;
+};
+typedef struct stow_notify *stow_notify_t;
+
+
+/* Called by MiG to translate ports into stow_notify_t.  mutations.h
+   arranges for this to happen for the fs_notify interfaces. */
+stow_notify_t begin_using_notify_port (fs_notify_t port);
+
+
+/* Called by MiG after server routines have been run; this balances
+   begin_using_notify_port, and is arranged for the fs_notify
+   interfaces by mutations.h. */
+void end_using_notify_port (stow_notify_t cred);
+
+#endif /* STOW_PRIVDATA_H */
diff --git a/unionfs/stow.c b/unionfs/stow.c
new file mode 100644
index 00000000..fa997472
--- /dev/null
+++ b/unionfs/stow.c
@@ -0,0 +1,328 @@
+/* Hurd unionfs
+   Copyright (C) 2005 Free Software Foundation, Inc.
+   Written by Gianluca Guida <glguida@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.  */
+
+
+/* Stow mode for unionfs.  */
+
+#define _GNU_SOURCE
+
+#include <argp.h>
+#include <error.h>
+
+#include "ulfs.h"
+#include "lib.h"
+#include "pattern.h"
+#include "update.h"
+
+struct stow_privdata
+{
+  struct patternlist *patternlist;
+  int flags;
+  int priority;
+  struct mutex lock;
+};
+
+static error_t
+_stow_registermatchingdirs (char *arg, char *dirpath, void *priv)
+{
+  error_t err = 0;
+  char *filepath;
+
+  struct stow_privdata *privdata = (struct stow_privdata *) priv ;
+
+  err = patternlist_match (privdata->patternlist, arg);
+  if (err)
+    return 0; /* It doesn't match. This is not an error.  */
+
+  filepath = make_filepath (dirpath, arg);
+
+  err = ulfs_register (filepath, privdata->flags, privdata->priority);
+
+  free (filepath);
+
+  if (err)
+    return err;
+  
+  return 0;
+}
+
+static error_t
+_stow_scanstowentry (char *arg, char *dirpath, void *priv)
+{
+  char *filepath = dirpath;
+  error_t err;
+
+  struct stow_privdata *privdata = (struct stow_privdata *) priv ;
+
+  if (dirpath) 
+    {
+      char *tmp;
+      tmp = make_filepath (dirpath, arg);
+      filepath = make_filepath (tmp, "/");
+      free (tmp);
+    }
+
+  mutex_lock (&privdata->lock);
+
+  if (patternlist_isempty (privdata->patternlist))
+    {
+
+      err = ulfs_register (filepath, privdata->flags, privdata->priority);
+      if (err)
+	{
+	  mutex_unlock (&privdata->lock);
+	  return err;
+	}
+
+    }
+  else
+    {
+      err = for_each_subdir_priv (filepath, _stow_registermatchingdirs, priv);
+      if (err)
+	{
+	  mutex_unlock (&privdata->lock);
+	  free (filepath);
+	  return err;
+	}
+    }
+
+  free (filepath);
+  mutex_unlock (&privdata->lock);
+  return err;
+}
+
+
+/* Implement server for fs_notify.  */
+
+#include <cthreads.h>
+#include <hurd/port.h>
+
+#include "stow-priv.h"
+#include "ncache.h"
+
+struct port_bucket *stow_port_bucket;
+struct port_class *stow_port_class;
+
+static error_t
+_stow_notify_init(char *dir_name, void *priv)
+{
+  error_t err;
+  file_t dir_port;
+  mach_port_t notify_port;
+  stow_notify_t stow_notify_port;
+
+  err = ports_create_port (stow_port_class, stow_port_bucket,
+			   sizeof (*stow_notify_port),
+			   &stow_notify_port);
+  if (err)
+    return err;
+
+  stow_notify_port->dir_name = dir_name;
+  stow_notify_port->priv = priv;
+
+  dir_port = file_name_lookup (dir_name, 0, 0); 
+
+  if (!port_valid (dir_port))
+      return ENOENT; /* ? */
+
+
+  notify_port = ports_get_right (stow_notify_port);
+
+  if (!port_valid (notify_port))
+    {
+      port_dealloc (dir_port);
+      return EACCES; /* ? */
+    }
+
+  err = dir_notice_changes (dir_port, notify_port, 
+			    MACH_MSG_TYPE_MAKE_SEND);
+  if (err)
+    {
+      port_dealloc (dir_port);
+      port_dealloc (notify_port);
+      return err;
+    }
+
+  return err;
+}
+
+/* Called by MiG to translate ports into stow_notify_t.  mutations.h
+   arranges for this to happen for the fs_notify interfaces. */
+stow_notify_t
+begin_using_notify_port (fs_notify_t port)
+{
+  return ports_lookup_port (stow_port_bucket, port, stow_port_class);
+}
+
+/* Called by MiG after server routines have been run; this balances
+   begin_using_notify_port, and is arranged for the fs_notify
+   interfaces by mutations.h. */
+void
+end_using_notify_port (stow_notify_t cred)
+{
+  if (cred)
+    ports_port_deref (cred);
+}
+
+/* We don't ask for file_changes, but this function has to be defined .  */
+kern_return_t
+stow_S_file_changed (stow_notify_t notify, natural_t tickno,
+		     file_changed_type_t change, loff_t start, 
+		     loff_t end)
+{
+  return EOPNOTSUPP;
+}
+
+/* Called when we receive a dir_changed message.  */
+kern_return_t
+stow_S_dir_changed (stow_notify_t notify, natural_t tickno,
+		    dir_changed_type_t change, string_t name)
+{
+  error_t err;
+
+  if (!notify || !notify->dir_name || !notify->priv)
+    return EOPNOTSUPP;
+
+  switch (change)
+    {
+    case DIR_CHANGED_NULL:
+      break;
+    case DIR_CHANGED_NEW:
+      root_update_disable ();
+
+      err = _stow_scanstowentry (name, notify->dir_name, notify->priv);
+      if (err)
+	  debug_msg_send ("scanstowentry: %s\n", strerror (err));
+
+      root_update_schedule ();
+      root_update_enable ();
+      break;
+
+    case DIR_CHANGED_UNLINK:
+      root_update_schedule ();
+      break;
+
+    default:
+      debug_msg_send ("unsupported dir change notify");
+      return EINVAL;
+    }
+
+  return 0;
+}
+
+/* This is the server thread waiting for dir_changed messages.  */
+static void
+_stow_notify_thread()
+{
+  int stow_demuxer (mach_msg_header_t *inp, mach_msg_header_t *outp)
+    {
+      int stow_fs_notify_server (mach_msg_header_t *inp,
+				 mach_msg_header_t *outp);
+      
+      return (stow_fs_notify_server (inp, outp));
+    }
+  
+  do
+    {
+      ports_manage_port_operations_multithread (stow_port_bucket,
+						 stow_demuxer,
+						 1000 * 60 * 2,
+						 1000 * 60 * 10,
+						 0);
+    }
+  while (1);
+}
+
+
+
+/* Interface to unionfs.  */
+
+error_t
+stow_diradd (char *dir, int flags, struct patternlist *patternlist, 
+	     int priority)
+{
+
+  error_t err;
+  struct stow_privdata *mypriv;
+  int dir_len;
+
+  dir_len = strlen(dir);
+  if (dir_len == 0)
+    {
+      return EOPNOTSUPP;
+    }
+
+  if (dir[dir_len - 1 ] != '/')
+    {
+      char *tmp;
+
+      tmp = (char *) malloc (dir_len + 1);
+
+      if (tmp == NULL)
+	return ENOMEM;
+
+      strncpy (tmp, dir, dir_len);
+
+      tmp[dir_len] = '/';
+
+      dir = tmp;
+    }
+
+  mypriv = malloc (sizeof (struct stow_privdata));
+  if (!mypriv)
+    {
+      free (dir);
+      return ENOMEM;
+    }
+
+  mypriv->patternlist = patternlist;
+  mypriv->flags = flags;
+  mypriv->priority = priority;
+  mutex_init (&mypriv->lock);
+  
+  err = for_each_subdir_priv (dir, _stow_scanstowentry, (void *)mypriv);
+  if (err)
+    {
+      /* FIXME: rescan and delete previous inserted things.  */
+      return err;
+    }
+
+  err = _stow_notify_init (dir, mypriv);
+  assert (!err);
+
+  return err;
+}
+
+error_t
+stow_init (void)
+{
+  error_t err = 0;
+
+  stow_port_bucket = ports_create_bucket ();
+  if (!stow_port_bucket)
+    return errno;
+
+  stow_port_class = ports_create_class (NULL, NULL);
+  if (!stow_port_class)
+    return errno;
+
+  cthread_detach (cthread_fork ( (cthread_fn_t)_stow_notify_thread, 0));
+
+  return err;
+}
diff --git a/unionfs/stow.h b/unionfs/stow.h
new file mode 100644
index 00000000..54ff7060
--- /dev/null
+++ b/unionfs/stow.h
@@ -0,0 +1,30 @@
+/* Hurd unionfs
+   Copyright (C) 2005 Free Software Foundation, Inc.
+   Written by Gianluca Guida <glguida@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.  */
+
+/* Stow mode for unionfs.  */
+
+#ifndef _STOW_H
+#define _STOW_H
+
+#include "pattern.h"
+
+error_t stow_init (void);
+error_t stow_diradd (char *, int, struct patternlist *, int);
+
+#endif /* _STOW_H  */
diff --git a/unionfs/stow.o b/unionfs/stow.o
new file mode 100644
index 00000000..fd5ca365
--- /dev/null
+++ b/unionfs/stow.o
diff --git a/unionfs/ulfs.c b/unionfs/ulfs.c
new file mode 100644
index 00000000..3c565a5c
--- /dev/null
+++ b/unionfs/ulfs.c
@@ -0,0 +1,321 @@
+/* Hurd unionfs
+   Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
+   Written by Moritz Schulte <moritz@duesseldorf.ccc.de>.
+
+   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.  */
+
+/* Underlying filesystem management.  */
+
+#define _GNU_SOURCE
+
+#include <hurd/netfs.h>
+#include <stdlib.h>
+#include <error.h>
+#include <string.h>
+
+#include "unionfs.h"
+#include <fcntl.h>
+
+#include "lib.h"
+#include "ulfs.h"
+
+/* The start of the ulfs chain.  */
+ulfs_t *ulfs_chain_start;
+
+/* The end of the ulfs chain, we need this, to go through the chain in
+   reversed order.  */
+ulfs_t *ulfs_chain_end;
+
+/* Number of registered underlying filesystems.  */
+unsigned int ulfs_num;
+
+/* The lock protecting the ulfs data structures.  */
+struct mutex ulfs_lock = MUTEX_INITIALIZER;
+
+/* Create a new ulfs element.  */
+static error_t
+ulfs_create (char *path, ulfs_t **ulfs)
+{
+  ulfs_t *ulfs_new = malloc (sizeof (ulfs_t));
+  error_t err = 0;
+  
+  if (! ulfs_new)
+    err = ENOMEM;
+  else
+    {
+      char *path_cp = path ? strdup (path) : NULL;
+
+      if (path && (! path_cp))
+	{
+	  err = ENOMEM;
+	  free (ulfs_new);
+	}
+      else
+	{
+	  ulfs_new->path = path_cp;
+	  ulfs_new->flags = 0;
+	  ulfs_new->next = NULL;
+	  ulfs_new->prev = NULL;
+	  *ulfs = ulfs_new;
+	}
+    }
+  return err;
+}
+
+/* Destroy an ulfs element.  */
+static void
+ulfs_destroy (ulfs_t *ulfs)
+{
+  free (ulfs->path);
+  free (ulfs);
+}
+
+/* Install ULFS into the linked list of registered filesystems in
+ * priority order.  */
+static void
+ulfs_install (ulfs_t *ulfs)
+{
+  ulfs_t *u = ulfs_chain_start;
+  int insert_at_end = 0;
+  if (ulfs_num == 0)
+    {
+      ulfs_chain_start = ulfs;
+      return;
+    }
+
+  /* walk the chain until a filesystem has a priority that's too high. */
+  while (u->priority > ulfs->priority)
+    {
+      if (u->next == NULL)
+	{
+	  insert_at_end = 1;
+	  break;
+	}
+      u = u->next;
+    }
+
+  if (insert_at_end)
+    {
+      u->next = ulfs;
+      ulfs->prev = u;
+    }
+  else
+    {
+      if (u == ulfs_chain_start)
+	{
+	  ulfs_chain_start = ulfs;
+	  ulfs->next = u;
+	  ulfs->prev = NULL;
+	  u->prev = ulfs;
+	}
+      else
+	{
+	  ulfs->next = u;
+	  ulfs->prev = u->prev;
+	  u->prev->next = ulfs;
+	  u->prev = ulfs;
+	}
+    }
+
+  return;
+}
+
+/* Remove ULFS from the linked list of registered filesystems.  */
+static void
+ulfs_uninstall (ulfs_t *ulfs)
+{
+  if (ulfs == ulfs_chain_start)
+      ulfs_chain_start = ulfs->next;
+
+  if (ulfs->next)
+    ulfs->next->prev = ulfs->prev;
+
+  if (ulfs->prev)
+    ulfs->prev->next = ulfs->next;
+}
+
+/* Get an ulfs element by it's index.  */
+error_t
+ulfs_get_num (int num, ulfs_t **ulfs)
+{
+  error_t err = EINVAL;
+  ulfs_t *u;
+  int i;
+
+  for (u = ulfs_chain_start, i = 0;
+       u && i < num;
+       u = u->next, i++);
+  if (u)
+    {
+      err = 0;
+      *ulfs = u;
+    }
+
+  return err;
+}
+
+/* Get an ulfs element by the associated path.  */
+static error_t
+ulfs_get_path (char *path, ulfs_t **ulfs)
+{
+  error_t err = ENOENT;
+  ulfs_t *u;
+
+  for (u = ulfs_chain_start;
+       u && (! (((! path) && path == u->path)
+		|| (path && u->path && (! strcmp (path, u->path)))));
+       u = u->next);
+  if (u)
+    {
+      err = 0;
+      *ulfs = u;
+    }
+  return err;
+}
+
+error_t
+ulfs_for_each_under_priv (char *path_under,
+			  error_t (*func) (char *, char *, void *),
+			  void *priv)
+{
+  error_t err = 0;
+  ulfs_t *u;
+  size_t length;
+  
+  length = strlen (path_under);
+
+  for (u = ulfs_chain_start; u; u = u->next)
+    {
+      if (!u->path)
+	continue;
+
+      if (memcmp (u->path, path_under, length))
+	continue;
+
+      /* This ulfs is under path_under.  */
+      func ((char *)(u->path + length), path_under, priv);
+    }
+
+  return err;
+}
+
+/* Register a new underlying filesystem.  */
+error_t
+ulfs_register (char *path, int flags, int priority)
+{
+  ulfs_t *ulfs;
+  error_t err;
+
+  if (path)
+    {
+      err = check_dir (path);
+      if (err)
+	  return err;
+    }
+
+  mutex_lock (&ulfs_lock);
+  err = ulfs_create (path, &ulfs);
+  if (! err)
+    {
+      ulfs->flags = flags;
+      ulfs->priority = priority;
+      ulfs_install (ulfs);
+      ulfs_num++;
+    }
+  mutex_unlock (&ulfs_lock);
+  return err;
+}
+
+/* Check for deleted ulfs entries.  */
+/* FIXME: Ugly as hell. Rewrite the whole ulfs.c  */
+void
+ulfs_check ()
+{
+  ulfs_t *u;
+  file_t p;
+
+  struct ulfs_destroy
+  {
+    ulfs_t *ulfs;
+
+    struct ulfs_destroy *next;
+  } *ulfs_destroy_q = NULL;
+
+  mutex_lock (&ulfs_lock);
+
+  u = ulfs_chain_start;
+  while (u)
+    {
+      
+      if (u->path)
+	p = file_name_lookup (u->path, O_READ | O_DIRECTORY, 0);
+      else
+	p = underlying_node;
+	  
+      if (! port_valid (p))
+	{
+	  struct ulfs_destroy *ptr;
+
+	  /* Add to destroy list.  */
+	  ptr = malloc (sizeof (struct ulfs_destroy));
+	  assert (ptr);
+
+	  ptr->ulfs = u;
+
+	  ptr->next = ulfs_destroy_q;
+	  ulfs_destroy_q = ptr;
+	}
+	  
+      u = u->next;
+    }
+
+  while (ulfs_destroy_q)
+    {
+      struct ulfs_destroy *ptr;
+
+      ptr = ulfs_destroy_q;
+      ulfs_destroy_q = ptr->next;
+
+      ulfs_uninstall (ptr->ulfs);
+      ulfs_destroy (ptr->ulfs);
+      ulfs_num--;	  
+
+      free (ptr);
+    }
+
+  mutex_unlock (&ulfs_lock);
+
+}
+
+/* Unregister an underlying filesystem.  */
+error_t
+ulfs_unregister (char *path)
+{
+  ulfs_t *ulfs;
+  error_t err;
+
+  mutex_lock (&ulfs_lock);
+  err = ulfs_get_path (path, &ulfs);
+  if (! err)
+    {
+      ulfs_uninstall (ulfs);
+      ulfs_destroy (ulfs);
+      ulfs_num--;
+    }
+  mutex_unlock (&ulfs_lock);
+
+  return err;
+}
diff --git a/unionfs/ulfs.h b/unionfs/ulfs.h
new file mode 100644
index 00000000..532e3c74
--- /dev/null
+++ b/unionfs/ulfs.h
@@ -0,0 +1,75 @@
+/* Hurd unionfs
+   Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
+   Written by Moritz Schulte <moritz@duesseldorf.ccc.de>.
+
+   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.  */
+
+/* Underlying filesystem management.  */
+
+#ifndef INCLUDED_ULFS_H
+#define INCLUDED_ULFS_H
+
+/* The structure for each registered underlying filesystem.  */
+typedef struct ulfs
+{
+  char *path;
+  int flags;
+  int priority;
+  struct ulfs *next, *prev;
+} ulfs_t;
+
+/* Flags.  */
+
+/* The according ulfs is marked writable.  */
+#define FLAG_ULFS_WRITABLE 0x00000001
+
+/* The start of the ulfs chain.  */
+extern ulfs_t *ulfs_chain_start;
+
+/* The end of the ulfs chain, we need this, to go through the chain in
+   reversed order.  */
+extern ulfs_t *ulfs_chain_end;
+
+/* Number of registered underlying filesystems.  */
+extern unsigned int ulfs_num;
+
+/* The lock protecting the ulfs data structures.  */
+extern struct mutex ulfs_lock;
+
+/* Register a new underlying filesystem.  */
+error_t ulfs_register (char *path, int flags, int priority);
+
+/* Unregister an underlying filesystem.  */
+error_t ulfs_unregister (char *path);
+
+/* Get an ULFS element by it's index.  */
+error_t ulfs_get_num (int num, ulfs_t **ulfs);
+
+/* Removes invalid ulfs entries.  */
+void ulfs_check (void);
+
+#define ulfs_iterate                             \
+  for (ulfs_t *ulfs = (mutex_lock (&ulfs_lock),  \
+		       ulfs_chain_start);          \
+       ulfs || (mutex_unlock (&ulfs_lock), 0);   \
+       ulfs = ulfs->next) 
+
+#define ulfs_iterate_unlocked                    \
+  for (ulfs_t *ulfs = ulfs_chain_start;            \
+       ulfs;                                     \
+       ulfs = ulfs->next)
+
+#endif
diff --git a/unionfs/ulfs.o b/unionfs/ulfs.o
new file mode 100644
index 00000000..1b4e4b32
--- /dev/null
+++ b/unionfs/ulfs.o
diff --git a/unionfs/unionfs.h b/unionfs/unionfs.h
new file mode 100644
index 00000000..8f5a0873
--- /dev/null
+++ b/unionfs/unionfs.h
@@ -0,0 +1,90 @@
+/* Hurd unionfs
+   Copyright (C) 2001, 2002 Free Software Foundation, Inc.
+   Written by Moritz Schulte <moritz@duesseldorf.ccc.de>.
+
+   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.  */
+
+/* This unionfs knows about two different kind of nodes: `light nodes'
+   (in short: lnode) and `nodes' (or: netfs nodes) as used by
+   libnetfs.  They have different tasks and therefore this division
+   makes sense.
+
+   lnodes form the filesystem tree as seen by the user; most
+   importantly they contain the `name' of the node.
+
+   lnodes are small and cheap, they are not cached (nodes are).
+
+   lnodes are usually created when a node is looked up and destroyed
+   when that node gets destroyed; but there are also reasons for
+   lnodes _not_ being destroyed.
+
+   The distinction makes it possible to keep certain information for
+   the unionfs in these lnodes while netfs nodes don't have to stay in
+   memory.  
+
+   lnodes have to be looked up first before a node is looked up.  Each
+   lnode contains a pointer to the netfs node, which might be NULL in
+   case the netfs node is not in memory anymore.  */
+
+/* General information and properties for the unionfs.  */
+
+#ifndef INCLUDED_UNIONFS_H
+#define INCLUDED_UNIONFS_H
+
+#include <hurd/netfs.h>
+#include <sys/types.h>
+
+#include "node.h"
+#include "lib.h"
+
+/* Default maximum number of nodes in the cache.  */
+#define NCACHE_SIZE 256
+
+/* The inode for the root node.  */
+#define UNIONFS_ROOT_INODE 1
+
+/* Flags for UNIONFS_FLAGS.  */
+
+/* Print debugging messages to stderr.  */
+#define FLAG_UNIONFS_MODE_DEBUG 0x00000001
+/* Use copy-on-write.  */
+#define FLAG_UNIONFS_MODE_COW   0x00000002
+
+/* Flags describing certain properties of the unionfs.  */
+extern int unionfs_flags;
+
+/* The filesystem id (the pid).  */
+extern pid_t fsid;
+
+/* Mapped time, used for updating node information.  */
+extern volatile struct mapped_time_value *maptime;
+
+/* A port to the underlying node.  */
+extern mach_port_t underlying_node;
+
+/* stat information for the underlying node.  */
+extern struct stat underlying_node_stat;
+
+/* Send a debugging message, if unionfs is in debugging mode.  */
+#define debug_msg(fmt, args...)                          \
+        do                                               \
+          {                                              \
+            if (unionfs_flags & FLAG_UNIONFS_MODE_DEBUG) \
+              debug_msg_send (fmt , ## args);            \
+          }                                              \
+        while (0)
+
+#endif
diff --git a/unionfs/update.c b/unionfs/update.c
new file mode 100644
index 00000000..8ec66883
--- /dev/null
+++ b/unionfs/update.c
@@ -0,0 +1,97 @@
+/* Hurd unionfs
+   Copyright (C) 2005 Free Software Foundation, Inc.
+   Written by Gianluca Guida <glguida@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.  */
+
+/* Update thread: A clean way to solve locking issues of 
+   root node update.  */
+
+#define _GNU_SOURCE
+
+#include <errno.h>
+#include <string.h>
+#include <cthreads.h>
+#include <rwlock.h>
+
+#include "ncache.h"
+#include "node.h"
+#include "ulfs.h"
+
+/* Reader lock is used by threads that are going to
+   add/remove an ulfs; writer lock is hold by the 
+   update thread.  */
+static struct rwlock update_rwlock;
+static struct condition update_wakeup;
+static struct mutex update_lock;
+
+static void
+_root_update_thread ()
+{
+  error_t err;
+  
+  while (1)
+    {
+      if (hurd_condition_wait (&update_wakeup, &update_lock))
+	mutex_unlock (&update_lock);
+
+      rwlock_writer_lock (&update_rwlock);
+
+      do 
+	{
+	  ulfs_check();
+	  err = node_init_root (netfs_root_node);
+	}
+      while (err == ENOENT);
+
+      if (err)
+	{
+	  fprintf (stderr, "update thread: got a %s\n", strerror (err));
+	}
+
+      ncache_reset ();
+
+      rwlock_writer_unlock (&update_rwlock);
+    }
+}
+
+void
+root_update_schedule ()
+{
+  condition_signal (&update_wakeup);
+}
+
+void
+root_update_disable ()
+{
+  rwlock_reader_lock (&update_rwlock);
+}
+
+void
+root_update_enable ()
+{
+  rwlock_reader_unlock (&update_rwlock);
+}
+
+void
+root_update_init()
+{
+  mutex_init (&update_lock);
+  rwlock_init (&update_rwlock);
+  condition_init (&update_wakeup);
+
+  cthread_detach (cthread_fork ( (cthread_fn_t)_root_update_thread, 0));
+}
diff --git a/unionfs/update.h b/unionfs/update.h
new file mode 100644
index 00000000..6ebd6fc6
--- /dev/null
+++ b/unionfs/update.h
@@ -0,0 +1,28 @@
+/* Hurd unionfs
+   Copyright (C) 2005 Free Software Foundation, Inc.
+   Written by Gianluca Guida <glguida@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 _UDPATE_H
+#define _UPDATE_H
+
+void root_update_schedule ();
+void root_update_disable ();
+void root_update_enable ();
+void root_update_init ();
+
+#endif /* UPDATE_H */
diff --git a/unionfs/update.o b/unionfs/update.o
new file mode 100644
index 00000000..c356ee6b
--- /dev/null
+++ b/unionfs/update.o
diff --git a/unionfs/version.h b/unionfs/version.h
new file mode 100644
index 00000000..8969db31
--- /dev/null
+++ b/unionfs/version.h
@@ -0,0 +1,29 @@
+/* Hurd version
+   Copyright (C) 1996, 1997, 1999 Free Software Foundation, Inc.
+   Written by Thomas Bushnell, n/BSG.
+
+   This file is part of the GNU Hurd.
+
+   The GNU Hurd 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, or (at
+   your option) any later version.
+
+   The GNU Hurd 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, USA. */
+
+#ifndef HURD_VERSION
+#define HURD_VERSION "0.3"
+#endif
+
+/* The standard way to print versions for --version.  */
+#define STANDARD_HURD_VERSION(s) \
+  #s " (GNU Hurd) " HURD_VERSION
+#define STANDARD_HURD_VERSION_EXTRA(s, extra) \
+  #s " (GNU Hurd; " extra ") " HURD_VERSION