$bq      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGH I J K L M N O P Q R S T U V W X YZ[\] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnop'"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe(A literal POSIX file pathas q9, but exceptions include the given path when appropriate.as r<, but exceptions include the given path when appropriate.as s<, but exceptions include the given path when appropriate.as t<, but exceptions include the given path when appropriate.as u<, but exceptions include the given path when appropriate.as v<, but exceptions include the given path when appropriate.   "(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe.rewindDirStream dp calls  rewinddir' to reposition the directory stream dp# at the beginning of the directory.closeDirStream dp calls closedir" to close the directory stream dp. wxyz"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe Z:IcreateDirectory dir mode calls mkdir to create a new directory, dir, with permissions based on mode.openDirStream dir calls opendir% to obtain a directory stream for dir.readDirStream dp calls readdir( to obtain the next directory entry ( struct dirent#) for the open directory stream dp, and returns the d_name member of that structure.getWorkingDirectory calls getcwd8 to obtain the name of the current working directory.changeWorkingDirectory dir calls chdir/ to change the current working directory to dir.   $(c) Volker Stolz <vs@foldr.org> 2003/BSD-style (see the file libraries/base/LICENSE) vs@foldr.org provisionalnon-portable (requires POSIX) TrustworthyF! Flags for !. Notice that #; might not be available on your particular platform! Use /.If  RTLD_DEFAULT" is not defined on your platform, 2 $ reduces to {.& Flags for "./+On some hosts (e.g. SuSe and Ubuntu Linux)  RTLD_NEXT (and  RTLD_DEFAULT-) are not visible without setting the macro  _GNU_SOURCEF. Since we don't want to define this macro, you can use the function / to check wether the flag #i is available. Ideally, this will be optimized by the compiler so that it should be as efficient as an #ifdef.CIf you fail to test the flag and use it although it is undefined, 2 will throw an error.!#$"%&'()*+,-./012.-,+/01&'()*2!#$"%#$(c) Volker Stolz <vs@foldr.org> 2003/BSD-style (see the file libraries/base/LICENSE) vs@foldr.org provisionalnon-portable (requires POSIX)SafeMl998 returns the address binding of the symbol described in symbol3, as it occurs in the shared object identified by source.::8 obtains the raw handle. You mustn't do something like -withDL mod flags $ liftM undl >>= p -> use p!#$"%&'()*+,-./0126|789:}$(c) Volker Stolz <vs@foldr.org> 2003/BSD-style (see the file libraries/base/LICENSE) vs@foldr.org provisionalnon-portable (requires POSIX)SafeP(!#$"%&'()*+,-./012789:;<=;987<=:$(c) Volker Stolz <vs@foldr.org> 2003/BSD-style (see the file libraries/base/LICENSE) vs@foldr.org provisionalnon-portable (requires POSIX)SafeR!#$"%&'()*+,-./012789:>?@>987?@:$(c) Volker Stolz <vs@foldr.org> 2003/BSD-style (see the file libraries/base/LICENSE) vs@foldr.org provisionalnon-portable (requires POSIX)SafeU6ABCDEF6ABCDEF$(c) Volker Stolz <vs@foldr.org> 2003/BSD-style (see the file libraries/base/LICENSE) vs@foldr.org provisionalnon-portable (requires POSIX)SafeXe6BCDEFG6GBCDEF "(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe nHH( looks up a variable in the environment.II is a wrapper around H_ where the programmer can specify a fallback if the variable is not found in the environment.KK0 retrieves the entire environment as a list of  (key,value) pairs.LL5 resets the entire environment to the given list of  (key,value) pairs.MThe MK function deletes all instances of the variable name from the environment.NN( function takes an argument of the form  name=value and is equivalent to #setEnv(key,value,True{-overwrite-}).OThe Oq function inserts or resets the environment variable name in the current environment list. If the variable namev does not exist in the list, it is inserted with the given value. If the variable does exist, the argument  overwrite is tested; if  overwrite is FalseK, the variable is not reset, otherwise it is reset to the given value.PThe P9 function clears the environment of all name-value pairs.Hvariable name variable value I!variable name !fallback value !variable value or fallback value K  [(key,value)]L  [(key,value)]Mvariable name N "key=value" Ovariable name variable value overwrite HIJKLMNOP HIJKLNOMP "(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Trustworthy QQ( looks up a variable in the environment.RR is a wrapper around Q_ where the programmer can specify a fallback if the variable is not found in the environment.TT0 retrieves the entire environment as a list of  (key,value) pairs.UThe UK function deletes all instances of the variable name from the environment.VV( function takes an argument of the form  name=value and is equivalent to #setEnv(key,value,True{-overwrite-}).WThe Wq function inserts or resets the environment variable name in the current environment list. If the variable namev does not exist in the list, it is inserted with the given value. If the variable does exist, the argument  overwrite is tested; if  overwrite is FalseK, the variable is not reset, otherwise it is reset to the given value.X Computation X^ returns a list of the program's command line arguments (not including the program name), as ~s.Unlike $%, this function does no Unicode decoding of the arguments; you get the exact bytes that were passed to the program by the OS. To interpret the arguments as text, some Unicode decoding should be applied.Qvariable name variable value R!variable name !fallback value !variable value or fallback value T  [(key,value)]Uvariable name V "key=value" Wvariable name variable value overwrite QRSTUVWXQRSTVWUX"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safea YZ[\ \[YZ "(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe Z]createDirectory dir mode calls mkdir to create a new directory, dir, with permissions based on mode.^openDirStream dir calls opendir% to obtain a directory stream for dir._readDirStream dp calls readdir( to obtain the next directory entry ( struct dirent#) for the open directory stream dp, and returns the d_name member of that structure.`getWorkingDirectory calls getcwd8 to obtain the name of the current working directory.achangeWorkingDirectory dir calls chdir/ to change the current working directory to dir. ]^_`ab ]b^_`a "(c) The University of Glasgow 2014 BSD-style (see the file LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe cAdvice parameter for j operation.'For more details, see documentation of posix_fadvise(2).j Performs posix_fadvise(2) operation on file-descriptor.If platform does not provide posix_fadvise(2) j becomes a no-op.(use #if HAVE_POSIX_FADVISE" CPP guard to detect availability)k Performs posix_fallocate(2) operation on file-descriptor.Throws 9 ("unsupported operation") if platform does not provide posix_fallocate(2).(use #if HAVE_POSIX_FALLOCATE# CPP guard to detect availability). cdefghijk cdefghijk&"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Trustworthyq1|POSIX defines operations to get information, such as owner, permissions, size and access times, about a file. This information is represented by the | type. Note: see chmod.}No permissions.~Owner has read permission.Owner has write permission.Owner has execute permission.Group has read permission.Group has write permission.Group has execute permission.Others have read permission.Others have write permission.Others have execute permission.Set user ID on execution.Set group ID on execution.7Owner, group and others have read and write permission.-Owner has read, write and execute permission.-Group has read, write and execute permission./Others have read, write and execute permission.@Owner, group and others have read, write and execute permission.PCombines the two file modes into one that contains modes that appear in either.OCombines two file modes into one that only contains modes that appear in both.setFdMode fd mode acts like  setFileMode but uses a file descriptor fd instead of a . Note: calls fchmod.setFileCreationMask mode% sets the file mode creation mask to mode. Modes set by this operation are subtracted from files and directories upon creation. The previous file creation mask is returned. Note: calls umask.,ID of the device on which this file resides. inode number File mode (such as permissions)."Number of hard links to this file. ID of owner. ID of group./Describes the device that this file represents.oSize of the file in bytes. If this file is a symbolic link the size is the length of the pathname it contains.Time of last access.Time of last modification.GTime of last status change (i.e. owner, group, link count, mode, etc.).-Time of last access in sub-second resolution.3Time of last modification in sub-second resolution.`Time of last status change (i.e. owner, group, link count, mode, etc.) in sub-second resolution.&Checks if this file is a block device.*Checks if this file is a character device.+Checks if this file is a named pipe device.-Checks if this file is a regular file device.*Checks if this file is a directory device..Checks if this file is a symbolic link device.'Checks if this file is a socket device.getFdStatus fd acts as  getFileStatus but uses a file descriptor fd. Note: calls fstat.Like setFileTimesHiRes but uses a file descriptor instead of a path. This operation is not supported on all platforms. On these platforms, this function will raise an exception. Note: calls futimens or futimes.Like  touchFile but uses a file descriptor instead of a path. This operation is not supported on all platforms. On these platforms, this function will raise an exception. Note: calls futimes.Acts as setOwnerAndGroup* but uses a file descriptor instead of a . Note: calls fchown.Acts as  setFileSize) but uses a file descriptor instead of a . Note: calls  ftruncate.getFdPathVar var fd obtains the dynamic value of the requested configurable file limit or option associated with the file or directory attached to the open channel fd. For defined file limits,  getFdPathVarJ returns the associated value. For defined file options, the result of  getFdPathVar is undefined, but not failure. Note: calls  fpathconf.Smnopqrstuvwxyz{|}~ "(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe setFileMode path mode) changes permission of the file given by path to mode. This operation may fail with  if pathd doesn't exist or if the effective user ID of the current process is not that of the file's owner. Note: calls chmod.fileAccess name read write exec3 checks if the file (or other file system object) nameq can be accessed for reading, writing and/or executing. To check a permission set the corresponding argument to . Note: calls access.%Checks for the existence of the file. Note: calls access.getFileStatus path calls gets the  FileStatus? information (user ID, size, access times, etc.) for the file path. Note: calls stat.Acts as  except when the . refers to a symbolic link. In that case the  FileStatus_ information of the symbolic link itself is returned instead of that of the file it points to. Note: calls lstat.createNamedPipe fifo mode creates a new named pipe, fifo, with permissions based on mode. May fail with  if a file named namep already exists or if the effective user ID of the current process doesn't have permission to create the pipe. Note: calls mkfifo.createDevice path mode devG creates either a regular or a special file depending on the value of mode (and dev). mode will normally be either  or . May fail with  if a file named namep already exists or if the effective user ID of the current process doesn't have permission to create the file. Note: calls mknod.createLink old new creates a new path, new, linked to an existing file, old. Note: calls link.removeLink path removes the link named path. Note: calls unlink.createSymbolicLink file1 file2 creates a symbolic link named file2 which points to the file file1.Symbolic links are interpreted at run-time as if the contents of the link had been substituted into the path being followed to find a file or directory. Note: calls symlink. Reads the  RawFilePath0 pointed to by the symbolic link and returns it. Note: calls readlink.rename old new" renames a file or directory from old to new. Note: calls rename.setOwnerAndGroup path uid gid changes the owner and group of path to uid and gid, respectively.If uid or gid1 is specified as -1, then that ID is not changed. Note: calls chown.Acts as Q but does not follow symlinks (and thus changes permissions on the link itself). Note: calls lchown.setFileTimes path atime mtime> sets the access and modification times associated with file path to atime and mtime, respectively. Note: calls utime.Like / but timestamps can have sub-second resolution. Note: calls  utimensat or utimes.Like  but does not follow symbolic links. This operation is not supported on all platforms. On these platforms, this function will raise an exception. Note: calls  utimensat or lutimes.touchFile path> sets the access and modification times associated with file path to the current time. Note: calls utime.Like  but does not follow symbolic links. This operation is not supported on all platforms. On these platforms, this function will raise an exception. Note: calls lutimes.Truncates the file down to the specified length. If the file was larger than the given length before this operation was performed the extra is lost. Note: calls truncate.getPathVar var pathq obtains the dynamic value of the requested configurable file limit or option associated with file or directory path. For defined file limits,  getPathVarI returns the associated value. For defined file options, the result of  getPathVar is undefined, but not failure. Note: calls pathconf.]mnopqrstuvwxyz{|}~]}~|mnopqrstuvwxyz{"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe RsetFileMode path mode) changes permission of the file given by path to mode. This operation may fail with  if pathd doesn't exist or if the effective user ID of the current process is not that of the file's owner. Note: calls chmod.fileAccess name read write exec3 checks if the file (or other file system object) nameq can be accessed for reading, writing and/or executing. To check a permission set the corresponding argument to . Note: calls access.%Checks for the existence of the file. Note: calls access.getFileStatus path calls gets the  FileStatus? information (user ID, size, access times, etc.) for the file path. Note: calls stat.Acts as  except when the . refers to a symbolic link. In that case the  FileStatus_ information of the symbolic link itself is returned instead of that of the file it points to. Note: calls lstat.createNamedPipe fifo mode creates a new named pipe, fifo, with permissions based on mode. May fail with  if a file named namep already exists or if the effective user ID of the current process doesn't have permission to create the pipe. Note: calls mkfifo.createDevice path mode devG creates either a regular or a special file depending on the value of mode (and dev). mode will normally be either  or . May fail with  if a file named namep already exists or if the effective user ID of the current process doesn't have permission to create the file. Note: calls mknod.createLink old new creates a new path, new, linked to an existing file, old. Note: calls link.removeLink path removes the link named path. Note: calls unlink.createSymbolicLink file1 file2 creates a symbolic link named file2 which points to the file file1.Symbolic links are interpreted at run-time as if the contents of the link had been substituted into the path being followed to find a file or directory. Note: calls symlink. Reads the FilePath0 pointed to by the symbolic link and returns it. Note: calls readlink.rename old new" renames a file or directory from old to new. Note: calls rename.setOwnerAndGroup path uid gid changes the owner and group of path to uid and gid, respectively.If uid or gid1 is specified as -1, then that ID is not changed. Note: calls chown.Acts as Q but does not follow symlinks (and thus changes permissions on the link itself). Note: calls lchown.setFileTimes path atime mtime> sets the access and modification times associated with file path to atime and mtime, respectively. Note: calls utime.Like / but timestamps can have sub-second resolution. Note: calls  utimensat or utimes.Like  but does not follow symbolic links. This operation is not supported on all platforms. On these platforms, this function will raise an exception. Note: calls  utimensat or lutimes.touchFile path> sets the access and modification times associated with file path to the current time. Note: calls utime.Like  but does not follow symbolic links. This operation is not supported on all platforms. On these platforms, this function will raise an exception. Note: calls lutimes.Truncates the file down to the specified length. If the file was larger than the given length before this operation was performed the extra is lost. Note: calls truncate.getPathVar var pathq obtains the dynamic value of the requested configurable file limit or option associated with file or directory path. For defined file limits,  getPathVarI returns the associated value. For defined file options, the result of  getPathVar is undefined, but not failure. Note: calls pathconf.]mnopqrstuvwxyz{|}~]}~|mnopqrstuvwxyz{'"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe "#ZzO_APPEND FD_CLOEXEC O_NONBLOCKO_SYNC5Correspond to some of the int flags from C's fcntl.h.O_APPENDO_EXCLO_NOCTTY O_NONBLOCKO_TRUNCThe D function creates a pair of connected file descriptors. The first component is the fd to read from, the second is the write end. Although pipes may be bidirectional, this behaviour is not portable and programmers should use two separate pipes for this purpose. May throw an exception if this is an invalid descriptor.8May throw an exception if this is an invalid descriptor.8May throw an exception if this is an invalid descriptor.Default values for the I type. False for each of append, exclusive, noctty, nonBlock, and trunc.+Open and optionally create this file. See ()$ for information on how to use the  type.VClose this file descriptor. May throw an exception if this is an invalid descriptor. Converts an  into a = that can be used with the standard Haskell IO library (see  System.IO). Extracts the  from a 5. This function has the side effect of closing the - and flushing its write buffer, if necessary.8May throw an exception if this is an invalid descriptor.8May throw an exception if this is an invalid descriptor.8May throw an exception if this is an invalid descriptor.8May throw an exception if this is an invalid descriptor.8May throw an exception if this is an invalid descriptor.8May throw an exception if this is an invalid descriptor.Read data from an  and convert it to a l using the locale encoding. Throws an exception if this is an invalid descriptor, or EOF has been reached.Read data from an 8 into memory. This is exactly equivalent to the POSIX read function.Write a  to an  using the locale encoding.Write data from memory to an ,. This is exactly equivalent to the POSIX write function.PJust x => creates the file with the given modes, Nothing => the file must exist.How many bytes to read)The bytes read, how many bytes were read.Memory in which to put the dataMaximum number of bytes to read#Number of bytes read (zero for EOF)#Memory containing the data to write Maximum number of bytes to writeNumber of bytes written*"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe+Open and optionally create this file. See ()$ for information on how to use the  type. ACreate and open this file in WriteOnly mode. A special case of . See ()$ for information on how to use the  type.PJust x => creates the file with the given modes, Nothing => the file must exist.+ + "(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe +Open and optionally create this file. See ()$ for information on how to use the  type. ACreate and open this file in WriteOnly mode. A special case of  . See ()$ for information on how to use the  type. PJust x => creates the file with the given modes, Nothing => the file must exist.+  +   Trustworthy k The exit status of a process the process exited by calling exit() or returning from main-the process was terminated by a signal, the Bool is True if a core dump was produced#the process was stopped by a signal    *"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Trustworthy QVi calls getpid to obtain the  for the current process. calls getppid to obtain the * for the parent of the current process. calls getpgrp to obtain the  for the current process.   pid calls getpgid to obtain the  for process pid.!! pid calls setpgid to make process pid a new process group leader."" pgid calls setpgid to set the  of the current process to pgid.## pid pgid calls setpgid to set the ProcessGroupIDOf for process pid to pgid.$$ calls setsidG to create a new session with the current process as session leader.%% calls timesS to obtain time-accounting information for the current process and its children.-- corresponds to the POSIX fork system call. The  action passed as an argument is executed in the child process; no other threads will be copied to the child process. On success, - returns the child's D to the parent process; in case of an error, an exception is thrown.FThe exception masking state of the executed action is inherited (c.f. forkIO ), see also . (since: 2.7.0.0).- comes with a giant warning: since any other running threads are not copied into the child process, it's easy to go wrong: e.g. by accessing some shared resource that was held by another thread in the parent.. Variant of - in the style of forkIOWithUnmask.// blk stopped pid calls waitpid, returning  tc, the   for process pid if it is available,  otherwise. If blk is  , then WNOHANG is set in the options for waitpid, otherwise not. If stopped is , then  WUNTRACED is set in the options for waitpid, otherwise not.00 blk stopped pgid calls waitpid, returning  (pid, tc), the  and   for any process in group pgid if one is available, or a if there are child processes but none have exited. If there are no child processes, then 0 raises an isDoesNotExistError exception.If blk is , then WNOHANG is set in the options for waitpid, otherwise not. If stopped is  , then  WUNTRACED is set in the options for waitpid, otherwise not.11 blk stopped calls waitpid, returning  (pid, tc), the  and  < for any child process if a child process has exited, or a if there are child processes but none have exited. If there are no child processes, then 1 raises an isDoesNotExistError exception.If blk is , then WNOHANG is set in the options for waitpid, otherwise not. If stopped is  , then  WUNTRACED is set in the options for waitpid, otherwise not.22 status calls _exit5 to terminate the process with the indicated exit status!. The operation never returns.33 pid calls setpgid to make process pid a new process group leader. This function is currently deprecated, and might be changed to making the current process a new process group leader in future versions.44 pid pgid calls setpgid to set the  for process pid to pgidS. This function is currently deprecated, and might be changed to setting the / for the current process in future versions.#   !"#$%&'()*+,-./01234"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)SafeΥ55 cmd args env calls one of the execv* family, depending on whether or not the current PATH is to be searched for the command, and whether or not an environment is provided to supersede the process's current environment. The basename (leading directory names suppressed) of the command is passed to execv* as arg[0]!; the argument list passed to 5 therefore begins with arg[1].5Command Search PATH? Arguments Environment$   !"#$%&'()*+,-./012345$-.52 !"#$%&'()*+,  /1034"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safet66 cmd args env calls one of the execv* family, depending on whether or not the current PATH is to be searched for the command, and whether or not an environment is provided to supersede the process's current environment. The basename (leading directory names suppressed) of the command is passed to execv* as arg[0]!; the argument list passed to 6 therefore begins with arg[1].6Command Search PATH? Arguments Environment$   !"#$%&'()*+,-./012346$-.62 !"#$%&'()*+,  /1034"(c) The University of Glasgow 2003/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe 7:89;<=>?@ABCDEFGH7:89;<=>?@ABCDEFGH(c) Daniel Franke 2007/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires POSIX)Safe O:If true, create the semaphore if it does not yet exist.P?If true, throw an exception if the semaphore already exists.QNOpen a named semaphore with the given name, flags, mode, and initial value.R)Delete the semaphore with the given name.SLock the semaphore, blocking until it becomes available. Since this is done through a system call, this will block the *entire runtime*, not just the current thread. If this is not the behaviour you want, use semThreadWait instead.TdAttempt to lock the semaphore without blocking. Immediately return False if it is not available.UPoll the semaphore until it is available, then lock it. Unlike semWait, this will block only the current thread rather than the entire process.VUnlock the semaphore.W%Return the semaphore's current value. LMNOPQRSTUVW MNOPLQRSTUVW(c) Daniel Franke 2007/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalnon-portable (requires POSIX)SafeZ>If true, open the shm object read-write rather than read-only.[4If true, create the shm object if it does not exist.\=If true, throw an exception if the shm object already exists.]>If true, wipe the contents of the shm object after opening it.^AOpen a shared memory object with the given name, flags, and mode._4Delete the shared memory object with the given name.XYZ[\]^_XYZ[\]^_"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Trustworthy 1Z$(aCInformation specific to a particular type of signal (derived from  siginfo_t).g2Information about a received signal (derived from  siginfo_t).l1The actions to perform when a signal is received.qrsignalProcess int pid calls kill to signal process pid with interrupt signal int.signalProcessGroup int pgid calls kill$ to signal all processes in group pgid with interrupt signal int.raiseSignal int calls kill8 to signal the current process with interrupt signal int.installHandler int handler iset calls  sigaction/ to install an interrupt handler for signal int. If handler is Default, SIG_DFL is installed; if handler is Ignore, SIG_IGN is installed; if handler is  Catch action., a handler is installed which will invoke actionJ in a new thread when (or shortly after) the signal is received. If iset is Just s , then the sa_mask of the  sigaction structure is set to sK; otherwise it is cleared. The previously installed signal handler for int is returnedscheduleAlarm i calls alarm+ to schedule a real time alarm at least i seconds in the future.+Tells the system whether or not to set the  SA_NOCLDSTOP+ flag when installing new signal handlers.4Queries the current state of the stopped child flag.eA set of signals reserved for use by the implementation. In GHC, this will normally include either  or v. getSignalMask calls  sigprocmaskI to determine the set of interrupts which are currently being blocked.setSignalMask mask calls  sigprocmask with  SIG_SETMASK to block all interrupts in mask.blockSignals mask calls  sigprocmask with  SIG_BLOCK to add all interrupts in mask$ to the set of blocked interrupts.unblockSignals mask calls  sigprocmask with  SIG_UNBLOCK to remove all interrupts in mask' from the set of blocked interrupts.getPendingSignals calls  sigpendingW to obtain the set of interrupts which have been received but are currently blocked.awaitSignal iset8 suspends execution until an interrupt is received. If iset is Just s,  awaitSignal calls  sigsuspend, installing sJ as the new signal mask before suspending execution; otherwise, it calls  sigsuspendC with current signal mask. Note that RTS scheduler signal (either  or t) could cause premature termination of this call. It might be necessary to block that signal before invocation of  awaitSignal with  . awaitSignal returns when signal was received and processed by a signal handler, or if the signal could not be caught. If you have installed any signal handlers with installHandler, it may be wise to call yield directly after  awaitSignalA to ensure that the signal handler runs as promptly as possible.other signals to block old handler``abcdefghijklmnopqrstuvwxyz{|}~`stuvwxyz{|}~lmnopqrghijkabcdef`  "(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisional9non-portable (requires POSIX, includes Linuxisms/BSDisms)Safe*/d`abcdefghijklmnopqrstuvwxyz{|}~X(c) Volker Stolz <vs@foldr.org> Deian Stefan <deian@cs.stanford.edu>/BSD-style (see the file libraries/base/LICENSE):libraries@haskell.org, vs@foldr.org, deian@cs.stanford.edu provisionalnon-portable (requires POSIX)Safe D!FMake a unique filename and open it for reading/writing. The returned  is the (possibly relative) path of the created file, which is padded with 6 random characters. The argument is the desired prefix of the filepath of the temporary file to be created.lIf you aren't using GHC or Hugs then this function simply wraps mktemp and so shouldn't be considered safe.eMake a unique filename with a given prefix and suffix and open it for reading/writing. The returned $ is the (possibly relative) path of the created file, which contains 6 random characters in between the prefix and suffix. The first argument is the desired prefix of the filepath of the temporary file to be created. The second argument is the suffix of the temporary file to be created.If you are using as system that doesn't support the mkstemps glibc function (supported in glibc > 2.11) then this function simply throws an error.&Make a unique directory. The returned  is the path of the created directory, which is padded with 6 random characters. The argument is the desired prefix of the filepath of the temporary directory to be created.If you are using as system that doesn't support the mkdtemp glibc function (supported in glibc > 2.1.91) then this function uses mktemp and so shouldn't be considered safe.X(c) Volker Stolz <vs@foldr.org> Deian Stefan <deian@cs.stanford.edu>/BSD-style (see the file libraries/base/LICENSE):libraries@haskell.org, vs@foldr.org, deian@cs.stanford.edu provisionalnon-portable (requires POSIX)Safe WFMake a unique filename and open it for reading/writing. The returned  is the (possibly relative) path of the created file, which is padded with 6 random characters. The argument is the desired prefix of the filepath of the temporary file to be created.lIf you aren't using GHC or Hugs then this function simply wraps mktemp and so shouldn't be considered safe. - make a unique filename with a given prefix and suffix and open it for reading/writing (only safe on GHC & Hugs). The returned } is the (possibly relative) path of the created file, which contains 6 random characters in between the prefix and suffix.&Make a unique directory. The returned  is the path of the created directory, which is padded with 6 random characters. The argument is the desired prefix of the filepath of the temporary directory to be created.lIf you aren't using GHC or Hugs then this function simply wraps mktemp and so shouldn't be considered safe.+"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Trustworthy pa TCOOFFTCOONTCIOFFTCION!getTerminalAttributes fd calls  tcgetattr to obtain the TerminalAttributes associated with Fd fd." setTerminalAttributes fd attr ts calls  tcsetattr to change the TerminalAttributes associated with Fd fd to attr1, when the terminal is in the state indicated by ts.#sendBreak fd duration calls  tcsendbreak; to transmit a continuous stream of zero-valued bits on Fd fd/ for the specified implementation-dependent duration.$drainOutput fd calls tcdrain) to block until all output written to Fd fd has been transmitted.Throws 9 ("unsupported operation") if platform does not provide  tcdrain(3) (use #if HAVE_TCDRAIN$ CPP guard to detect availability).%discardData fd queues calls tcflush/ to discard pending input and/or output for Fd fd, as indicated by the  QueueSelector queues.&controlFlow fd action calls tcflow# to control the flow of data on Fd fd, as indicated by action.'getTerminalProcessGroupID fd calls  tcgetpgrp to obtain the ProcessGroupIDM of the foreground process group associated with the terminal attached to Fd fd.(!setTerminalProcessGroupID fd pgid calls  tcsetpgrp to set the ProcessGroupIDM of the foreground process group associated with the terminal attached to Fd fd to pgid.)queryTerminal fd calls isatty to determine whether or not Fd fd is associated with a terminal.a      !"#$%&'()"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe .*getTerminalName fd calls ttyname6 to obtain a name associated with the terminal for Fd fd. If fd# is associated with a terminal, getTerminalName% returns the name of the terminal.+getControllingTerminalName calls ctermidx to obtain a name associated with the controlling terminal for the process. If a controlling terminal exists, getControllingTerminalName1 returns the name of the controlling terminal.Throws 9 ("unsupported operation") if platform does not provide  ctermid(3) (use #if HAVE_CTERMID$ CPP guard to detect availability).,getSlaveTerminalName calls ptsname to obtain the name of the slave terminal associated with a pseudoterminal pair. The file descriptor to pass in must be that of the master.-openPseudoTerminalP creates a pseudoterminal (pty) pair, and returns the newly created pair as a (master, slave) tuple.d      !"#$%&'()*+,-d!"      #$%&'()*+-,"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe .getTerminalName fd calls ttyname6 to obtain a name associated with the terminal for Fd fd. If fd# is associated with a terminal, getTerminalName% returns the name of the terminal./getControllingTerminalName calls ctermidx to obtain a name associated with the controlling terminal for the process. If a controlling terminal exists, getControllingTerminalName1 returns the name of the controlling terminal.Throws 9 ("unsupported operation") if platform does not provide  ctermid(3) (use #if HAVE_CTERMID$ CPP guard to detect availability).0getSlaveTerminalName calls ptsname to obtain the name of the slave terminal associated with a pseudoterminal pair. The file descriptor to pass in must be that of the master.1openPseudoTerminalP creates a pseudoterminal (pty) pair, and returns the newly created pair as a (master, slave) tuple.d      !"#$%&'()./01d!"      #$%&'()./10"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe  2 epochTime calls timea to obtain the number of seconds that have elapsed since the epoch (Jan 01 00:00:00 GMT 1970).22"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe ZDSleep for the specified duration (in seconds). Returns the time remaining (if the sleep was interrupted by a signal, for example).GHC Note: ,-P is a better choice. Since GHC uses signals for its internal clock, a call to D7 will usually be interrupted immediately. That makes DR unusable in a program compiled with GHC, unless the RTS timer is disabled (with +RTS -V0). Furthermore, without the  -threaded option, D3 will block all other user threads. Even with the  -threaded option, D( requires a full OS thread to itself. ,- has none of these shortcomings.E3Sleep for the specified duration (in microseconds).GHC Note: ,-" is a better choice. Without the  -threaded option, E4 will block all other user threads. Even with the  -threaded option, E( requires a full OS thread to itself. ,-$ has neither of these shortcomings.F1Sleep for the specified duration (in nanoseconds)GHC Note: the comment for E also applies here.H Performs fsync(2) operation on file-descriptor.Throws 9 ("unsupported operation") if platform does not provide fsync(2) (use #if HAVE_FSYNC$ CPP guard to detect availability).I Performs  fdatasync(2) operation on file-descriptor.Throws 9 ("unsupported operation") if platform does not provide  fdatasync(2) (use #if HAVE_FDATASYNC$ CPP guard to detect availability).3645789:;<=@>?ABCDEFGHI<=@>?ABC3645789:;GDEFHI"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX) Trustworthy rL#Textual name of this user (pw_name)M@Password -- may be empty or fake if shadow is in use (pw_passwd)N!Numeric ID for this user (pw_uid)OPrimary group ID (pw_gid)P-Usually the real name for the user (pw_gecos)QHome directory (pw_dir)RDefault shell (pw_shell)U The name of this group (gr_name)V'The password for this group (gr_passwd)W-The unique numeric ID for this group (gr_gid)X:A list of zero or more usernames that are members (gr_mem)Y getRealUserID calls getuid to obtain the real UserID( associated with the current process.ZgetRealGroupID calls getgid to obtain the real GroupID( associated with the current process.[getEffectiveUserID calls geteuid to obtain the effective UserID% associated with the current process.\getEffectiveGroupID calls getegid to obtain the effective GroupID% associated with the current process.] getGroups calls  getgroups( to obtain the list of supplementary GroupID&s associated with the current process.^ setGroups calls  setgroups% to set the list of supplementary GroupID&s associated with the current process._ getLoginName calls getloginA to obtain the login name associated with the current process.` setUserID uid calls setuid] to set the real, effective, and saved set-user-id associated with the current process to uid.asetEffectiveUserID uid calls seteuidH to set the effective user-id associated with the current process to uid:. This does not update the real user-id or set-user-id.bsetGroupID gid calls setgid^ to set the real, effective, and saved set-group-id associated with the current process to gid.csetEffectiveGroupID uid calls setegidI to set the effective group-id associated with the current process to gid<. This does not update the real group-id or set-group-id.dgetEffectiveUserName0 gets the name associated with the effective UserID of the process.egetGroupEntryForID gid calls  getgrgid_r to obtain the  GroupEntry information associated with GroupID gid. This operation may fail with  if no such group exists.fgetGroupEntryForName name calls  getgrnam_r to obtain the  GroupEntry1 information associated with the group called name. This operation may fail with  if no such group exists.ggetAllGroupEntriesB returns all group entries on the system by repeatedly calling getgrenthgetUserEntryForID gid calls  getpwuid_r to obtain the  UserEntry information associated with UserID uid. This operation may fail with  if no such user exists.igetUserEntryForName name calls  getpwnam_r to obtain the  UserEntry/ information associated with the user login name. This operation may fail with  if no such user exists.jgetAllUserEntriesA returns all user entries on the system by repeatedly calling getpwent!JKLMNOPQRSTUVWXYZ[\]^_`abcdefghij!YZ[\]_dSTUVWXefgJKLMNOPQRhij`bac^."(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe9 !#"%&'()*+,-./012789:;<=QRSTUVWXmnopqrstuvwxyz{|}~    !"#$%&'()*+,-./0123457:89;<=>?@ABCDEFGHLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-23645789:;<=@>?ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghij!#"%&'()*+,-./012789:;<=("(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org provisionalnon-portable (requires POSIX)Safe9!#"%&'()*+,-./012789:>?@HIJKLMNOP]^_`abmnopqrstuvwxyz{|}~     !"#$%&'()*+,-./0123467:89;<=>?@ABCDEFGHLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()./0123645789:;<=@>?ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghij!#"%&'()*+,-./012789:>?@/01/02/03/04/05/06789:;<=>654321 ? @ A B C D EFGHIJKLMNOPQRSTUVWXYZ[\]^_`#a#b#c#!#d"ef"efghijklg m n o p q r s t u m n o p r s t %;<=> F G H I J K v w x y z { | } ~ &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& '''''''''''''''''''''''''''''''''''''''''     ***************** *!*"*#*$*%*&*'*(*)***+*,*-*.//012033456789:;<=>?@ABCDDEFGHIJKLMNNOPQRSTUVWXYZ[\\]^_`Oabcdefghijklmnopqrstuvwxyz{|}~++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + + + ++++++++++++ !"#$%&'(()*+,-./01234556789:;<==>?@ABCDEFGHIJKLMNOPQRSTUVWXY/0Z/0[/0\/0]/0^/0_ ? ` a @/bc#a#defg/hi/jk&l&l&m&m&&n&o&p&q&r&stuv'w/xy/xz/{|/}~/x/xtu/}/}tu///x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/x/xz/x/x/x/x/x"/x/x/x/x/xunix-2.7.2.2-inplaceSystem.Posix.Error System.Posix.ByteString.FilePath!System.Posix.Directory.ByteStringSystem.Posix.DynamicLinker.Prim!System.Posix.DynamicLinker.Module%System.Posix.DynamicLinker.ByteStringSystem.Posix.DynamicLinker,System.Posix.DynamicLinker.Module.ByteStringSystem.Posix.EnvSystem.Posix.Env.ByteStringSystem.Posix.DirectorySystem.Posix.FcntlSystem.Posix.Files.ByteStringSystem.Posix.FilesSystem.Posix.IO.ByteStringSystem.Posix.IOSystem.Posix.Process.InternalsSystem.Posix.Process.ByteStringSystem.Posix.ProcessSystem.Posix.ResourceSystem.Posix.SemaphoreSystem.Posix.SharedMemSystem.Posix.SignalsSystem.Posix.Signals.ExtsSystem.Posix.TempSystem.Posix.Temp.ByteString System.Posix.Terminal.ByteStringSystem.Posix.TerminalSystem.Posix.TimeSystem.Posix.UnistdSystem.Posix.UserSystem.Posix.Directory.Commondlsymdlopen!System.Posix.DynamicLinker.CommonSystem.EnvironmentgetArgsSystem.Posix.Files.CommonSystem.Posix.IO.Common System.PosixFilesSystem.Posix.Process.CommonSystem.Posix.Terminal.CommonControl.Concurrent threadDelaySystem.Posix.ByteStringbaseForeign.C.ErrorthrowErrnoPathIfMinus1_throwErrnoPathIfMinus1throwErrnoPathIfNullthrowErrnoPathIf_throwErrnoPathIfthrowErrnoPath RawFilePath withFilePath peekFilePathpeekFilePathLenthrowErrnoPathIfMinus1RetrythrowErrnoPathIfMinus1Retry_throwErrnoPathIfNullRetrythrowErrnoPathIfRetryDirStreamOffset DirStreamrewindDirStreamcloseDirStream seekDirStream tellDirStreamchangeWorkingDirectoryFdcreateDirectory openDirStream readDirStreamgetWorkingDirectorychangeWorkingDirectoryremoveDirectoryDLNullNextDefaultDLHandle RTLDFlags RTLD_LAZYRTLD_NOW RTLD_GLOBAL RTLD_LOCAL c_dlclose c_dlerrorc_dlsymc_dlopen haveRtldNext haveRtldLocal packRTLDFlagspackDL$fShowRTLDFlags$fReadRTLDFlags$fShowDLModuledlclosedlerrorundlwithDLwithDL_ moduleOpen moduleSymbol moduleClose moduleError withModule withModule_getEnv getEnvDefaultgetEnvironmentPrimgetEnvironmentsetEnvironmentunsetEnvputEnvsetEnvclearEnvAdvice AdviceNormal AdviceRandomAdviceSequentialAdviceWillNeedAdviceDontNeed AdviceNoReuse fileAdvise fileAllocate $fEqAdvicePathVar FileSizeBits LinkLimitInputLineLimitInputQueueLimit FileNameLimit PathNameLimitPipeBufferLimitSymbolicLinkLimitSetOwnerAndGroupIsRestrictedFileNamesAreNotTruncated VDisableCharAsyncIOAvailablePrioIOAvailableSyncIOAvailable FileStatus nullFileMode ownerReadModeownerWriteModeownerExecuteMode groupReadModegroupWriteModegroupExecuteMode otherReadModeotherWriteModeotherExecuteMode setUserIDModesetGroupIDMode stdFileMode ownerModes groupModes otherModes accessModesunionFileModesintersectFileModes fileTypeModesblockSpecialModecharacterSpecialMode namedPipeModeregularFileMode directoryModesymbolicLinkMode socketMode setFdModesetFileCreationMaskdeviceIDfileIDfileMode linkCount fileOwner fileGroupspecialDeviceIDfileSize accessTimemodificationTimestatusChangeTimeaccessTimeHiResmodificationTimeHiResstatusChangeTimeHiRes isBlockDeviceisCharacterDevice isNamedPipe isRegularFile isDirectoryisSymbolicLinkisSocket getFdStatussetFdTimesHiRestouchFdsetFdOwnerAndGroup setFdSize getFdPathVar setFileMode fileAccess fileExist getFileStatusgetSymbolicLinkStatuscreateNamedPipe createDevice createLink removeLinkcreateSymbolicLinkreadSymbolicLinkrenamesetOwnerAndGroupsetSymbolicLinkOwnerAndGroup setFileTimessetFileTimesHiRessetSymbolicLinkTimesHiRes touchFiletouchSymbolicLink setFileSize getPathVarFileLock LockRequestReadLock WriteLockUnlockFdOption AppendOnWrite CloseOnExecNonBlockingReadSynchronousWrites OpenFileFlagsappend exclusivenocttynonBlocktruncOpenModeReadOnly WriteOnly ReadWrite createPipedupdupTostdInput stdOutputstdErrordefaultFileFlagscloseFd fdToHandle handleToFd queryFdOption setFdOptionfdSeekgetLocksetLock waitToSetLockfdRead fdReadBuffdWrite fdWriteBufopenFd createFile ProcessStatusExited TerminatedStopped c_execvpepPrPr_disableITimersdecipherWaitStatus$fEqProcessStatus$fOrdProcessStatus$fShowProcessStatus ProcessTimes elapsedTimeuserTime systemTime childUserTimechildSystemTime getProcessIDgetParentProcessIDgetProcessGroupIDgetProcessGroupIDOfcreateProcessGroupForjoinProcessGroupsetProcessGroupIDOf createSessiongetProcessTimesnicegetProcessPrioritygetProcessGroupPrioritygetUserPrioritysetProcessPrioritysetProcessGroupPrioritysetUserPriority forkProcessforkProcessWithUnmaskgetProcessStatusgetGroupProcessStatusgetAnyProcessStatusexitImmediatelycreateProcessGroupsetProcessGroupID executeFile ResourceLimitResourceLimitInfinityResourceLimitUnknownResourceLimits softLimit hardLimitResourceResourceCoreFileSizeResourceCPUTimeResourceDataSizeResourceFileSizeResourceOpenFilesResourceStackSizeResourceTotalMemorygetResourceLimitsetResourceLimit $fEqResource$fEqResourceLimit$fEqResourceLimits Semaphore OpenSemFlags semCreate semExclusivesemOpen semUnlinksemWait semTryWait semThreadWaitsemPost semGetValue ShmOpenFlags shmReadWrite shmCreate shmExclusiveshmTruncshmOpen shmUnlink SignalSetSignalSpecificInfoNoSignalSpecificInfo SigChldInfo siginfoPid siginfoUid siginfoStatus SignalInfo siginfoSignal siginfoErrorsiginfoSpecificHandlerIgnoreCatch CatchOnce CatchInfo CatchInfoOnceSignal nullSignalsigABRTsigALRMsigBUSsigCHLDsigCONTsigFPEsigHUPsigILLsigINTsigKILLsigPIPEsigQUITsigSEGVsigSTOPsigTERMsigTSTPsigTTINsigTTOUsigUSR1sigUSR2sigPOLLsigPROFsigSYSsigTRAPsigURG sigVTALRMsigXCPUsigXFSZ internalAbort realTimeAlarmbusErrorprocessStatusChangedcontinueProcessfloatingPointExceptionlostConnectionillegalInstructionkeyboardSignal killProcess openEndedPipekeyboardTerminationsegmentationViolation softwareStopsoftwareTermination keyboardStopbackgroundReadbackgroundWriteuserDefinedSignal1userDefinedSignal2 pollableEventprofilingTimerExpired badSystemCallbreakpointTrapurgentDataAvailablevirtualTimerExpiredcpuTimeLimitExceededfileSizeLimitExceeded signalProcesssignalProcessGroup raiseSignalinstallHandler scheduleAlarmsetStoppedChildFlagqueryStoppedChildFlagemptySignalSet fullSignalSetreservedSignals addSignal deleteSignal inSignalSet getSignalMask setSignalMask blockSignalsunblockSignalsgetPendingSignals awaitSignalsigINFOsigWINCH infoEvent windowChangemkstempmkstempsmkdtemp FlowAction SuspendOutput RestartOutput TransmitStop TransmitStart QueueSelector InputQueue OutputQueue BothQueues TerminalState Immediately WhenDrained WhenFlushedBaudRateB0B50B75B110B134B150B200B300B600B1200B1800B2400B4800B9600B19200B38400B57600B115200ControlCharacter EndOfFile EndOfLineErase InterruptKillQuitStartStopSuspend TerminalModeInterruptOnBreak MapCRtoLF IgnoreBreakIgnoreCRIgnoreParityErrors MapLFtoCR CheckParity StripHighBitStartStopInputStartStopOutputMarkParityErrors ProcessOutput LocalMode ReadEnable TwoStopBits HangupOnClose EnableParity OddParity EnableEcho EchoEraseEchoKillEchoLF ProcessInputExtendedFunctionsKeyboardInterruptsNoFlushOnInterruptBackgroundWriteInterruptTerminalAttributes withoutModewithMode terminalMode bitsPerBytewithBits controlCharwithCC withoutCC inputTimewithTimeminInput withMinInput inputSpeedwithInputSpeed outputSpeedwithOutputSpeedgetTerminalAttributessetTerminalAttributes sendBreak drainOutput discardData controlFlowgetTerminalProcessGroupIDsetTerminalProcessGroupID queryTerminalgetTerminalNamegetControllingTerminalNamegetSlaveTerminalNameopenPseudoTerminal epochTimeSysVar ArgumentLimit ChildLimit ClockTick GroupLimit OpenFileLimit PosixVersion HasSavedIDs HasJobControlSystemID systemNamenodeNamereleaseversionmachine getSystemIDsleepusleep nanosleep getSysVarfileSynchronisefileSynchroniseDataOnly UserEntryuserName userPassworduserID userGroupID userGecos homeDirectory userShell GroupEntry groupName groupPasswordgroupID groupMembers getRealUserIDgetRealGroupIDgetEffectiveUserIDgetEffectiveGroupID getGroups setGroups getLoginName setUserIDsetEffectiveUserID setGroupIDsetEffectiveGroupIDgetEffectiveUserNamegetGroupEntryForIDgetGroupEntryForNamegetAllGroupEntriesgetUserEntryForIDgetUserEntryForNamegetAllUserEntries$fShowGroupEntry$fReadGroupEntry$fEqGroupEntry$fShowUserEntry$fReadUserEntry $fEqUserEntry throwErrno throwErrnoIf throwErrnoIf_throwErrnoIfNullthrowErrnoIfMinus1throwErrnoIfMinus1_CDirentCDirGHC.PtrnullPtrthrowDLErrorIfbytestring-0.10.8.2Data.ByteString.Internal ByteStringGHC.IO.ExceptionIOErrorGHC.IOFilePathCTimeVal CTimeSpec c_lutimesc_utimes c_utimensat toCTimeSpec toCTimeVal pathVarConstghc-prim GHC.TypesTrueopen_System.Posix.TypesFileModeFdGHC.IO.Handle.TypesHandleGHC.BaseString ProcessIDProcessGroupIDIOJustNothingFalseSystem.Posix.InternalsCTermiosSystem.IO.ErrorisDoesNotExistErrorCDevCInoCModeCOffCPidCSsizeCGidCNlinkCUidCCcCSpeedCTcflagCRLimCBlkSizeCBlkCntCClockId CFsBlkCnt CFsFilCntCIdCKeyCTimer LinkCountUserIDGroupID ByteCount EpochTimeDeviceIDFileID FileOffsetLimit