sig
  val version : string
  val run_with_in_channel : (unit -> unit) -> Pervasives.in_channel
  val run_with_out_channel : (unit -> unit) -> Pervasives.out_channel
  val run_with_file : (unit -> unit) -> string
  val run_with_string : (unit -> unit) -> string
  val run_with_strings : (unit -> unit) -> string list
  val run_with_sexp : (unit -> unit) -> Sexp.simple
  val run_with_sexps : (unit -> unit) -> Sexp.simple list
  val string_of_in_channel : Pervasives.in_channel -> string
  val sexp_list_of_in_channel : Pervasives.in_channel -> Sexp.simple list
  val string_list_of_in_channel : Pervasives.in_channel -> string list
  val list_of_in_channel :
    (Pervasives.in_channel -> 'a) -> Pervasives.in_channel -> 'a list
  val fold_in_channel :
    Pervasives.in_channel ->
    (Pervasives.in_channel -> 'a) -> ('-> '-> 'b) -> '-> 'b
  type proc = Proc_3_4.proc
  val run_with_inchan_plus_proc :
    (unit -> unit) -> Pervasives.in_channel * Cash.proc
  val run_with_outchan_plus_proc :
    (unit -> unit) -> Pervasives.out_channel * Cash.proc
  type fd = int
  val run_with_collecting :
    Cash.fd list ->
    (unit -> unit) -> Unix.process_status * Pervasives.in_channel list
  val char_filter : (char -> char) -> unit -> unit
  val string_filter : ?buflen:int -> (string -> string) -> unit -> unit
  val errno_error : Unix.error -> string -> string -> 'a
  val unwind_protect : (unit -> 'a) -> ('-> unit) -> '-> 'a
  val close_fd_after : Cash.fd -> (Cash.fd -> 'a) -> 'a
  val close_in_after :
    Pervasives.in_channel -> (Pervasives.in_channel -> 'a) -> 'a
  val close_out_after :
    Pervasives.out_channel -> (Pervasives.out_channel -> 'a) -> 'a
  val with_stdin : Pervasives.in_channel -> (unit -> 'a) -> 'a
  val with_stdout : Pervasives.out_channel -> (unit -> 'a) -> 'a
  val with_stderr : Pervasives.out_channel -> (unit -> 'a) -> 'a
  val set_stdin : Pervasives.in_channel -> unit
  val set_stdout : Pervasives.out_channel -> unit
  val set_stderr : Pervasives.out_channel -> unit
  val close_in : Pervasives.in_channel -> bool
  val close_out : Pervasives.out_channel -> bool
  val close_fd : Cash.fd -> bool
  val stdchans_to_stdio : unit -> unit
  val stdio_to_stdchans : unit -> unit
  val with_stdio_chans : (unit -> 'a) -> 'a
  val make_string_in_channel : string -> Pervasives.in_channel
  val make_string_out_channel : unit -> Pervasives.out_channel
  val string_out_channel_output :
    ?close:bool -> Pervasives.out_channel -> string
  val call_with_string_out_channel :
    ?close:bool -> (Pervasives.out_channel -> unit) -> string
  val in_channel_of_fd : Cash.fd -> Pervasives.in_channel
  val out_channel_of_fd : Cash.fd -> Pervasives.out_channel
  val fd_of_in_channel : Pervasives.in_channel -> Cash.fd
  val fd_of_out_channel : Pervasives.out_channel -> Cash.fd
  external in_channel_revealed : Pervasives.in_channel -> int
    = "chan_revealed_count"
  external out_channel_revealed : Pervasives.out_channel -> int
    = "chan_revealed_count"
  external release_in_channel_handle : Pervasives.in_channel -> unit
    = "release_chan_handle"
  external release_out_channel_handle : Pervasives.out_channel -> unit
    = "release_chan_handle"
  val call_with_fdes_in : (Cash.fd -> 'a) -> Pervasives.in_channel -> 'a
  val call_with_fdes_out : (Cash.fd -> 'a) -> Pervasives.out_channel -> 'a
  val move_fd_to_fdes : Cash.fd -> Cash.fd -> Cash.fd
  val move_in_channel_to_fdes :
    Pervasives.in_channel -> Cash.fd -> Pervasives.in_channel
  val move_out_channel_to_fdes :
    Pervasives.out_channel -> Cash.fd -> Pervasives.out_channel
  val dup_fd : ?newfd:Cash.fd -> Cash.fd -> Cash.fd
  val fdes_of_dup_in : ?newfd:Cash.fd -> Pervasives.in_channel -> Cash.fd
  val fdes_of_dup_out : ?newfd:Cash.fd -> Pervasives.out_channel -> Cash.fd
  val in_channel_of_dup_fd :
    ?newfd:Cash.fd -> Cash.fd -> Pervasives.in_channel
  val dup_in :
    ?newfd:Cash.fd -> Pervasives.in_channel -> Pervasives.in_channel
  val in_channel_of_dup_out :
    ?newfd:Cash.fd -> Pervasives.out_channel -> Pervasives.in_channel
  val out_channel_of_dup_fd :
    ?newfd:Cash.fd -> Cash.fd -> Pervasives.out_channel
  val out_channel_of_dup_in :
    ?newfd:Cash.fd -> Pervasives.in_channel -> Pervasives.out_channel
  val dup_out :
    ?newfd:Cash.fd -> Pervasives.out_channel -> Pervasives.out_channel
  type seek_command = Unix.seek_command = SEEK_SET | SEEK_CUR | SEEK_END
  val seek_fd : ?whence:Cash.seek_command -> Cash.fd -> int -> int
  val seek_in :
    ?whence:Cash.seek_command -> Pervasives.in_channel -> int -> int
  val seek_out :
    ?whence:Cash.seek_command -> Pervasives.out_channel -> int -> int
  val tell_fd : Cash.fd -> int
  val tell_in : Pervasives.in_channel -> int
  val tell_out : Pervasives.out_channel -> int
  type file_perm = int
  and open_flag =
    Unix.open_flag =
      O_RDONLY
    | O_WRONLY
    | O_RDWR
    | O_NONBLOCK
    | O_APPEND
    | O_CREAT
    | O_TRUNC
    | O_EXCL
    | O_NOCTTY
    | O_DSYNC
    | O_SYNC
    | O_RSYNC
  val open_file_out :
    ?perms:Cash.file_perm ->
    string -> Cash.open_flag list -> Pervasives.out_channel
  val open_file_in :
    ?perms:Cash.file_perm ->
    string -> Cash.open_flag list -> Pervasives.in_channel
  val open_fdes :
    ?perms:Cash.file_perm -> string -> Cash.open_flag list -> Cash.fd
  val open_input_file :
    ?flags:Cash.open_flag list -> string -> Pervasives.in_channel
  val open_output_file :
    ?flags:Cash.open_flag list ->
    ?perms:Cash.file_perm -> string -> Pervasives.out_channel
  val openfile :
    string -> Cash.open_flag list -> Cash.file_perm -> Unix.file_descr
  val with_input_from_file : string -> (unit -> 'a) -> 'a
  val with_output_to_file : string -> (unit -> 'a) -> 'a
  val with_errors_to_file : string -> (unit -> 'a) -> 'a
  val call_with_input_file : string -> (Pervasives.in_channel -> 'a) -> 'a
  val call_with_output_file : string -> (Pervasives.out_channel -> 'a) -> 'a
  val call_with_fdes_fn :
    ?perms:Cash.file_perm ->
    string -> Cash.open_flag list -> (Cash.fd -> 'a) -> 'a
  type fdes_flags = FD_CLOEXEC
  val fdes_flags_fd : Cash.fd -> Cash.fdes_flags list
  val fdes_flags_in : Pervasives.in_channel -> Cash.fdes_flags list
  val fdes_flags_out : Pervasives.out_channel -> Cash.fdes_flags list
  val set_fdes_flags_fd : Cash.fd -> Cash.fdes_flags list -> unit
  val set_fdes_flags_in :
    Pervasives.in_channel -> Cash.fdes_flags list -> unit
  val set_fdes_flags_out :
    Pervasives.out_channel -> Cash.fdes_flags list -> unit
  val fdes_status_fd : Cash.fd -> Cash.open_flag list
  val fdes_status_in : Pervasives.in_channel -> Cash.open_flag list
  val fdes_status_out : Pervasives.out_channel -> Cash.open_flag list
  val set_fdes_status_fd : Cash.fd -> Cash.open_flag list -> unit
  val set_fdes_status_in :
    Pervasives.in_channel -> Cash.open_flag list -> unit
  val set_fdes_status_out :
    Pervasives.out_channel -> Cash.open_flag list -> unit
  val pipe : unit -> Pervasives.in_channel * Pervasives.out_channel
  val fold_input : ('-> '-> 'a) -> '-> ('-> 'b) -> '-> 'a
  type error_packet =
      Sys__error of string
    | Unix__error of (Unix.error * string * string)
  exception String_io_error of
              (Cash.error_packet * string * string * int * int * int)
  val read_string : ?src:Cash.fd -> int -> string
  val read_string_in : ?src:Pervasives.in_channel -> int -> string
  val read_string_bang :
    ?src:Cash.fd -> ?start:int -> ?end_:int -> string -> int
  val read_string_bang_in :
    ?src:Pervasives.in_channel -> ?start:int -> ?end_:int -> string -> int
  val read_string_partial : ?src:Cash.fd -> int -> string
  val read_string_partial_in : ?src:Pervasives.in_channel -> int -> string
  val read_string_bang_partial :
    ?src:Cash.fd -> ?start:int -> ?end_:int -> string -> int
  val read_string_bang_partial_in :
    ?src:Pervasives.in_channel -> ?start:int -> ?end_:int -> string -> int
  val write_string :
    ?dst:Cash.fd -> ?start:int -> ?end_:int -> string -> unit
  val write_string_out :
    ?dst:Pervasives.out_channel -> ?start:int -> ?end_:int -> string -> unit
  val write_string_partial :
    ?dst:Cash.fd -> ?start:int -> ?end_:int -> string -> int
  val write_string_partial_out :
    ?dst:Pervasives.out_channel -> ?start:int -> ?end_:int -> string -> int
  type selectable =
      Nothing
    | Read_in of Pervasives.in_channel
    | Read_fd of Cash.fd
    | Write_out of Pervasives.out_channel
    | Write_fd of Cash.fd
    | Except_in of Pervasives.in_channel
    | Except_fd of Cash.fd
  val select_bang :
    ?timeout:float -> Cash.selectable array -> int * int * int
  val select :
    ?timeout:float -> Cash.selectable array -> Cash.selectable array
  type bufpolicy = Block | Line | Nobuf
  val set_chan_buffering_in :
    Pervasives.in_channel -> ?size:int -> Cash.bufpolicy -> unit
  val set_chan_buffering_out :
    Pervasives.out_channel -> ?size:int -> Cash.bufpolicy -> unit
  val force_output : Pervasives.out_channel -> unit
  val flush_all_chans : unit -> unit
  type override = Don't | Delete | Query
  val create_directory :
    ?perms:Cash.file_perm -> ?override:Cash.override -> string -> unit
  val create_fifo :
    ?perms:Cash.file_perm -> ?override:Cash.override -> string -> unit
  val create_hard_link : ?override:Cash.override -> string -> string -> unit
  val create_symlink : ?override:Cash.override -> string -> string -> unit
  val delete_file : string -> unit
  val delete_directory : string -> unit
  val delete_filesys_object : string -> bool
  val read_symlink : string -> string
  val rename_file : ?override:Cash.override -> string -> string -> unit
  val set_file_mode_fn : string -> Cash.file_perm -> unit
  val set_file_mode_fd : Cash.fd -> Cash.file_perm -> unit
  val set_file_mode_in : Pervasives.in_channel -> Cash.file_perm -> unit
  val set_file_mode_out : Pervasives.out_channel -> Cash.file_perm -> unit
  val set_file_owner_fn : string -> int -> unit
  val set_file_owner_fd : Cash.fd -> int -> unit
  val set_file_owner_in : Pervasives.in_channel -> int -> unit
  val set_file_owner_out : Pervasives.out_channel -> int -> unit
  val set_file_group_fn : string -> int -> unit
  val set_file_group_fd : Cash.fd -> int -> unit
  val set_file_group_in : Pervasives.in_channel -> int -> unit
  val set_file_group_out : Pervasives.out_channel -> int -> unit
  val set_file_times : ?times:float * float -> string -> unit
  val sync_file_fd : int -> unit
  val sync_file_out : Pervasives.out_channel -> unit
  val sync_file_system : unit -> unit
  val truncate_file_fn : string -> int -> unit
  val truncate_file_fd : Cash.fd -> int -> unit
  val truncate_file_in : Pervasives.in_channel -> int -> unit
  val truncate_file_out : Pervasives.out_channel -> int -> unit
  type file_kind =
    Unix.file_kind =
      S_REG
    | S_DIR
    | S_CHR
    | S_BLK
    | S_LNK
    | S_FIFO
    | S_SOCK
  and file_info =
    Unix.stats = {
    st_dev : int;
    st_ino : int;
    st_kind : Cash.file_kind;
    st_perm : Cash.file_perm;
    st_nlink : int;
    st_uid : int;
    st_gid : int;
    st_rdev : int;
    st_size : int;
    st_atime : float;
    st_mtime : float;
    st_ctime : float;
  } 
  val file_info_fn : ?chase:bool -> string -> Cash.file_info
  val file_info_fd : Cash.fd -> Cash.file_info
  val file_info_in : Pervasives.in_channel -> Cash.file_info
  val file_info_out : Pervasives.out_channel -> Cash.file_info
  val file_type_fn : ?chase:bool -> string -> Cash.file_kind
  val file_type_fd : Cash.fd -> Cash.file_kind
  val file_type_in : Pervasives.in_channel -> Cash.file_kind
  val file_type_out : Pervasives.out_channel -> Cash.file_kind
  val file_inode_fn : ?chase:bool -> string -> int
  val file_inode_fd : Cash.fd -> int
  val file_inode_in : Pervasives.in_channel -> int
  val file_inode_out : Pervasives.out_channel -> int
  val file_mode_fn : ?chase:bool -> string -> Cash.file_perm
  val file_mode_fd : Cash.fd -> Cash.file_perm
  val file_mode_in : Pervasives.in_channel -> Cash.file_perm
  val file_mode_out : Pervasives.out_channel -> Cash.file_perm
  val file_nlinks_fn : ?chase:bool -> string -> int
  val file_nlinks_fd : Cash.fd -> int
  val file_nlinks_in : Pervasives.in_channel -> int
  val file_nlinks_out : Pervasives.out_channel -> int
  val file_owner_fn : ?chase:bool -> string -> int
  val file_owner_fd : Cash.fd -> int
  val file_owner_in : Pervasives.in_channel -> int
  val file_owner_out : Pervasives.out_channel -> int
  val file_group_fn : ?chase:bool -> string -> int
  val file_group_fd : Cash.fd -> int
  val file_group_in : Pervasives.in_channel -> int
  val file_group_out : Pervasives.out_channel -> int
  val file_size_fn : ?chase:bool -> string -> int
  val file_size_fd : Cash.fd -> int
  val file_size_in : Pervasives.in_channel -> int
  val file_size_out : Pervasives.out_channel -> int
  val file_last_access_fn : ?chase:bool -> string -> float
  val file_last_access_fd : Cash.fd -> float
  val file_last_access_in : Pervasives.in_channel -> float
  val file_last_access_out : Pervasives.out_channel -> float
  val file_last_mod_fn : ?chase:bool -> string -> float
  val file_last_mod_fd : Cash.fd -> float
  val file_last_mod_in : Pervasives.in_channel -> float
  val file_last_mod_out : Pervasives.out_channel -> float
  val file_last_status_change_fn : ?chase:bool -> string -> float
  val file_last_status_change_fd : Cash.fd -> float
  val file_last_status_change_in : Pervasives.in_channel -> float
  val file_last_status_change_out : Pervasives.out_channel -> float
  val is_file_directory_fn : ?chase:bool -> string -> bool
  val is_file_directory_fd : Cash.fd -> bool
  val is_file_directory_in : Pervasives.in_channel -> bool
  val is_file_directory_out : Pervasives.out_channel -> bool
  val is_file_fifo_fn : ?chase:bool -> string -> bool
  val is_file_fifo_fd : Cash.fd -> bool
  val is_file_fifo_in : Pervasives.in_channel -> bool
  val is_file_fifo_out : Pervasives.out_channel -> bool
  val is_file_regular_fn : ?chase:bool -> string -> bool
  val is_file_regular_fd : Cash.fd -> bool
  val is_file_regular_in : Pervasives.in_channel -> bool
  val is_file_regular_out : Pervasives.out_channel -> bool
  val is_file_socket_fn : ?chase:bool -> string -> bool
  val is_file_socket_fd : Cash.fd -> bool
  val is_file_socket_in : Pervasives.in_channel -> bool
  val is_file_socket_out : Pervasives.out_channel -> bool
  val is_file_special_fn : ?chase:bool -> string -> bool
  val is_file_special_fd : Cash.fd -> bool
  val is_file_special_in : Pervasives.in_channel -> bool
  val is_file_special_out : Pervasives.out_channel -> bool
  val is_file_symlink_fn : string -> bool
  val is_file_symlink_fd : Cash.fd -> bool
  val is_file_symlink_in : Pervasives.in_channel -> bool
  val is_file_symlink_out : Pervasives.out_channel -> bool
  type accessibility =
      Accessible
    | Unaccessible
    | Permission
    | No_directory
    | Nonexistent
  val is_file_not_readable_fn : string -> Cash.accessibility
  val is_file_not_readable_fd : Cash.fd -> Cash.accessibility
  val is_file_not_readable_in : Pervasives.in_channel -> Cash.accessibility
  val is_file_not_readable_out : Pervasives.out_channel -> Cash.accessibility
  val is_file_not_writable_fn : string -> Cash.accessibility
  val is_file_not_writable_fd : Cash.fd -> Cash.accessibility
  val is_file_not_writable_in : Pervasives.in_channel -> Cash.accessibility
  val is_file_not_writable_out : Pervasives.out_channel -> Cash.accessibility
  val is_file_not_executable_fn : string -> Cash.accessibility
  val is_file_not_executable_fd : Cash.fd -> Cash.accessibility
  val is_file_not_executable_in : Pervasives.in_channel -> Cash.accessibility
  val is_file_not_executable_out :
    Pervasives.out_channel -> Cash.accessibility
  val is_file_readable_fn : string -> bool
  val is_file_readable_fd : Cash.fd -> bool
  val is_file_readable_in : Pervasives.in_channel -> bool
  val is_file_readable_out : Pervasives.out_channel -> bool
  val is_file_writable_fn : string -> bool
  val is_file_writable_fd : Cash.fd -> bool
  val is_file_writable_in : Pervasives.in_channel -> bool
  val is_file_writable_out : Pervasives.out_channel -> bool
  val is_file_executable_fn : string -> bool
  val is_file_executable_fd : Cash.fd -> bool
  val is_file_executable_in : Pervasives.in_channel -> bool
  val is_file_executable_out : Pervasives.out_channel -> bool
  type existing = Existing | Unexisting | Search_denied
  val file_not_exists_fn : ?chase:bool -> string -> Cash.existing
  val file_not_exists_fd : Cash.fd -> Cash.existing
  val file_not_exists_in : Pervasives.in_channel -> Cash.existing
  val file_not_exists_out : Pervasives.out_channel -> Cash.existing
  val is_file_existing_fn : ?chase:bool -> string -> bool
  val is_file_existing_fd : Cash.fd -> bool
  val is_file_existing_in : Pervasives.in_channel -> bool
  val is_file_existing_out : Pervasives.out_channel -> bool
  val fold_directory : ('-> string -> 'a) -> '-> string -> 'a
  val directory_files : ?dot_files:bool -> string -> string list
  val glob : string list -> string list
  val glob_quote : string -> string
  type file_match_pattern =
      String_pat of string
    | Regexp_pat of Pcre.regexp
    | Predicate_pat of (string -> bool)
  val file_match :
    ?dot_files:bool -> string -> Cash.file_match_pattern list -> string list
  val create_temp_file : ?prefix:string -> unit -> string
  val set_temp_file_template : string * string -> unit
  val with_temp_file_template : string * string -> (unit -> 'a) -> 'a
  val temp_file_iterate :
    ?template:string * string -> (string -> 'a option) -> 'a
  val temp_file_channel :
    unit -> Pervasives.in_channel * Pervasives.out_channel
  val exec : string -> string list -> unit
  val exec_path : string -> string list -> 'a
  val exec_with_env :
    string -> ?env:(string * string) list -> string list -> unit
  val exec_path_with_env :
    string -> ?env:(string * string) list -> string list -> 'a
  val low_exec : string -> ?env:(string * string) list -> string list -> unit
  val exec_path_search : string -> string list -> string
  val exit : int -> 'a
  external low_exit : int -> 'a = "sys_exit"
  val call_terminally : (unit -> unit) option -> 'a option
  val suspend : unit -> unit
  val fork : unit -> Cash.proc option
  val fork_child : (unit -> unit) -> Cash.proc
  val low_fork : ?child:(unit -> unit) -> unit -> Cash.proc option
  val fork_with_pipe : unit -> Cash.proc option
  val fork_child_with_pipe : (unit -> unit) -> Cash.proc
  val low_fork_with_pipe : ?child:(unit -> unit) -> unit -> Cash.proc option
  val fork_with_pipe_plus : Cash.fd list list -> Cash.proc option
  val fork_child_with_pipe_plus :
    (unit -> 'a) -> Cash.fd list list -> Cash.proc
  val low_fork_with_pipe_plus :
    ?child:(unit -> 'a) -> Cash.fd list list -> Cash.proc option
  val pid_of_proc : Cash.proc -> int
  type probe_pid = Proc_3_4.probe_pid = Probe | Create | Don't_probe
  val proc_of_pid : ?probe:Cash.probe_pid -> int -> Cash.proc option
  type autoreap_policy =
    Proc_3_4.autoreap_policy =
      No_autoreaping
    | Early
    | Late
  val autoreap_policy :
    ?policy:Cash.autoreap_policy -> unit -> Cash.autoreap_policy
  val reap_zombies : unit -> bool
  type process_status =
    Unix.process_status =
      WEXITED of int
    | WSIGNALED of int
    | WSTOPPED of int
  exception Child_not_ready
  type wait_flag = Unix.wait_flag = WNOHANG | WUNTRACED
  val wait : ?wflags:Cash.wait_flag list -> Cash.proc -> Cash.process_status
  val wait_pid : ?wflags:Cash.wait_flag list -> int -> Cash.process_status
  type wait_any =
    Proc_3_4.wait_any =
      None_ready
    | No_children
    | Exited of (Cash.proc * Cash.process_status)
  val wait_any : ?wflags:Cash.wait_flag list -> unit -> Cash.wait_any
  val wait_process_group :
    ?wflags:Cash.wait_flag list -> Cash.proc -> Cash.wait_any
  val wait_process_group_pgrp :
    ?wflags:Cash.wait_flag list -> int -> Cash.wait_any
  val umask : unit -> int
  val set_umask : int -> unit
  val with_umask : int -> (unit -> 'a) -> 'a
  val chdir : ?dir:string -> unit -> unit
  val cwd : unit -> string
  val with_cwd : string -> (unit -> 'a) -> 'a
  val pid : unit -> int
  val parent_pid : unit -> int
  val process_group : unit -> int
  val set_process_group : ?proc:Cash.proc -> int -> unit
  val set_process_group_pid : int -> int -> unit
  type prio = Proc_state_3_5.prio = Prio_process | Prio_pgrp | Prio_user
  val set_priority : ?who:Cash.proc -> Cash.prio -> int -> unit
  val set_priority_pid : int -> Cash.prio -> int -> unit
  val priority : ?who:Cash.proc -> Cash.prio -> int
  val priority_pid : int -> Cash.prio -> int
  val nice : ?proc:Cash.proc -> int -> unit
  val nice_pid : int -> int -> unit
  val user_login_name : unit -> string
  val user_uid : unit -> int
  val user_effective_uid : unit -> int
  val user_gid : unit -> int
  val user_effective_gid : unit -> int
  val user_supplementary_gids : unit -> int array
  val set_uid : int -> unit
  val set_gid : int -> unit
  type process_times =
    Unix.process_times = {
    tms_utime : float;
    tms_stime : float;
    tms_cutime : float;
    tms_cstime : float;
  } 
  val process_times : unit -> Cash.process_times
  val cpu_ticks_per_sec : unit -> int
  type user_info =
    User_group_3_6.user_info = {
    ui_name : string;
    ui_uid : int;
    ui_gid : int;
    ui_home_dir : string;
    ui_shell : string;
  } 
  val user_info : int -> Cash.user_info
  val user_info_name : string -> Cash.user_info
  val username_to_uid : string -> int
  val uid_to_username : int -> string
  type group_info =
    User_group_3_6.group_info = {
    gi_name : string;
    gi_gid : int;
    gi_members : string list;
  } 
  val group_info : int -> Cash.group_info
  val group_info_name : string -> Cash.group_info
  val groupname_to_gid : string -> int
  val gid_to_groupname : int -> string
  val command_line_arguments : string list option Pervasives.ref
  val command_line : unit -> string list
  val make_command_line_arguments : unit -> string list
  val arg : ?default:'-> 'a list -> int -> 'a
  val arg_star : ?default_thunk:(unit -> 'a) -> 'a list -> int -> 'a
  val argv : ?default:string -> int -> string
  val system_name : unit -> string
  val signal_process : Cash.proc -> int -> unit
  val signal_process_pid : int -> int -> unit
  val signal_process_group : Cash.proc -> int -> unit
  val signal_process_group_pgrp : int -> int -> unit
  type itimer =
    Unix.interval_timer =
      ITIMER_REAL
    | ITIMER_VIRTUAL
    | ITIMER_PROF
  and itimer_status =
    Unix.interval_timer_status = {
    it_interval : float;
    it_value : float;
  } 
  val itimer :
    ?newstat:Cash.itimer_status -> Cash.itimer -> Cash.itimer_status
  val pause_until_interrupt : unit -> unit
  val sleep : int -> unit
  val sleep_until : float -> unit
  type date =
    Time_3_10.date = {
    seconds : int;
    minute : int;
    hour : int;
    month_day : int;
    month : int;
    year : int;
    tz_name : string option;
    tz_secs : int option;
    is_summer : bool option;
    week_day : int;
    year_day : int;
  } 
  val make_date :
    ?tzn:string ->
    ?tzs:int ->
    ?summ:bool ->
    ?wday:int ->
    ?yday:int -> int -> int -> int -> int -> int -> int -> Cash.date
  type time_zone =
    Time_3_10.time_zone =
      Tz_local
    | Tz_secs of int
    | Tz_name of string
  val time_plus_ticks : unit -> float
  val ticks_per_sec : unit -> float
  val date : unit -> Cash.date
  val date_of_time : ?tz:Cash.time_zone -> float -> Cash.date
  val time : unit -> float
  val time_of_date : Cash.date -> float
  val string_of_date : Cash.date -> string
  val format_date : string -> Cash.date -> string
  val getenv : string -> string
  val setenv : ?sval:string -> string -> unit
  val alist_of_env : unit -> (string * string) list
  val setenv_from_alist : (string * string) list -> unit
  val alist_delete : '-> ('a * 'b) list -> ('a * 'b) list
  val alist_update : '-> '-> ('a * 'b) list -> ('a * 'b) list
  val alist_compress : ('a * bool) list -> ('a * bool) list
  val with_env : (string * string) list -> (unit -> 'a) -> 'a
  val with_total_env : (string * string) list -> (unit -> 'a) -> 'a
  val add_before : '-> '-> 'a list -> 'a list
  val add_after : '-> '-> 'a list -> 'a list
  val home_directory : string Pervasives.ref
  val exec_path_list : unit -> string list
  val set_exec_path_list : string list -> unit
  val with_exec_path_list : string list -> (unit -> 'a) -> 'a
  val is_tty_fd : Cash.fd -> bool
  val is_tty_in : Pervasives.in_channel -> bool
  val is_tty_out : Pervasives.out_channel -> bool
  val tty_file_name_fd : Cash.fd -> string
  val tty_file_name_in : Pervasives.in_channel -> string
  val tty_file_name_out : Pervasives.out_channel -> string
  type tty_info = {
    control_chars : string;
    input_flags : nativeint;
    output_flags : nativeint;
    control_flags : nativeint;
    local_flags : nativeint;
    input_speed : int;
    output_speed : int;
    min : int;
    time : int;
  } 
  and tty_chars = {
    delete_char : int;
    delete_line : int;
    eof : int;
    eol : int;
    interrupt : int;
    quit : int;
    suspend : int;
    start : int;
    stop : int;
    delayed_suspend : int;
    delete_word : int;
    discard : int;
    eol2 : int;
    literal_next : int;
    reprint : int;
    status : int;
  } 
  val ttychar : Cash.tty_chars
  val disable_tty_char : char
  type tty_in = {
    check_parity : nativeint;
    ignore_bad_parity_chars : nativeint;
    mark_parity_errors : nativeint;
    ignore_break : nativeint;
    interrupt_on_break : nativeint;
    seven_bits : nativeint;
    cr_to_nl : nativeint;
    ignore_cr : nativeint;
    nl_to_cr : nativeint;
    input_flow_ctl : nativeint;
    output_flow_ctl : nativeint;
    xon_any : nativeint;
    beep_on_overflow : nativeint;
    lowercase : nativeint;
  } 
  val ttyin : Cash.tty_in
  type tty_out = {
    enable : nativeint;
    nl_to_crnl : nativeint;
    discard_eot : nativeint;
    expand_tabs : nativeint;
    cr_to_nl : nativeint;
    nl_does_cr : nativeint;
    no_col0_cr : nativeint;
    delay_with_fill_char : nativeint;
    fill_with_del : nativeint;
    uppercase : nativeint;
    bs_delay : nativeint;
    bs_delay0 : nativeint;
    bs_delay1 : nativeint;
    cr_delay : nativeint;
    cr_delay0 : nativeint;
    cr_delay1 : nativeint;
    cr_delay2 : nativeint;
    cr_delay3 : nativeint;
    ff_delay : nativeint;
    ff_delay0 : nativeint;
    ff_delay1 : nativeint;
    tab_delay : nativeint;
    tab_delay0 : nativeint;
    tab_delay1 : nativeint;
    tab_delay2 : nativeint;
    tab_delayx : nativeint;
    nl_delay : nativeint;
    nl_delay0 : nativeint;
    nl_delay1 : nativeint;
    vtab_delay : nativeint;
    vtab_delay0 : nativeint;
    vtab_delay1 : nativeint;
    all_delay : nativeint;
  } 
  val ttyout : Cash.tty_out
  type tty_c = {
    char_size : nativeint;
    char_size5 : nativeint;
    char_size6 : nativeint;
    char_size7 : nativeint;
    char_size8 : nativeint;
    enable_parity : nativeint;
    odd_parity : nativeint;
    enable_read : nativeint;
    hup_on_close : nativeint;
    no_modem_sync : nativeint;
    two_stop_bits : nativeint;
    ignore_flags : nativeint;
    cts_output_flow_control : nativeint;
    rts_input_flow_control : nativeint;
    carrier_flow_ctl : nativeint;
  } 
  val ttyc : Cash.tty_c
  type tty_l = {
    canonical : nativeint;
    echo : nativeint;
    echo_delete_lines : nativeint;
    echo_nl : nativeint;
    visual_delete : nativeint;
    enable_signals : nativeint;
    extended : nativeint;
    no_flush_on_interrupt : nativeint;
    ttou_signal : nativeint;
    echo_ctl : nativeint;
    flush_output : nativeint;
    hardcopy_delete : nativeint;
    reprint_unread_chars : nativeint;
    visual_delete_line : nativeint;
    alt_delete_word : nativeint;
    no_kernel_status : nativeint;
    case_map : nativeint;
  } 
  val ttyl : Cash.tty_l
  val make_tty_info :
    nativeint ->
    nativeint ->
    nativeint -> nativeint -> int -> int -> int -> int -> Cash.tty_info
  val copy_tty_info : Cash.tty_info -> Cash.tty_info
  val tty_info_fd : Cash.fd -> Cash.tty_info
  val tty_info_in : Pervasives.in_channel -> Cash.tty_info
  val tty_info_out : Pervasives.out_channel -> Cash.tty_info
  val tty_info_fn : string -> Cash.tty_info
  val set_tty_info_now_fd : Cash.fd -> Cash.tty_info -> unit
  val set_tty_info_now_in : Pervasives.in_channel -> Cash.tty_info -> unit
  val set_tty_info_now_out : Pervasives.out_channel -> Cash.tty_info -> unit
  val set_tty_info_now_fn : string -> Cash.tty_info -> unit
  val set_tty_info_drain_fd : Cash.fd -> Cash.tty_info -> unit
  val set_tty_info_drain_in : Pervasives.in_channel -> Cash.tty_info -> unit
  val set_tty_info_drain_out :
    Pervasives.out_channel -> Cash.tty_info -> unit
  val set_tty_info_drain_fn : string -> Cash.tty_info -> unit
  val set_tty_info_flush_fd : Cash.fd -> Cash.tty_info -> unit
  val set_tty_info_flush_in : Pervasives.in_channel -> Cash.tty_info -> unit
  val set_tty_info_flush_out :
    Pervasives.out_channel -> Cash.tty_info -> unit
  val set_tty_info_flush_fn : string -> Cash.tty_info -> unit
  val send_tty_break_fd : ?duration:int -> Cash.fd -> unit
  val send_tty_break_in : ?duration:int -> Pervasives.in_channel -> unit
  val send_tty_break_out : ?duration:int -> Pervasives.out_channel -> unit
  val send_tty_break_fn : ?duration:int -> string -> unit
  val drain_tty_fd : Cash.fd -> unit
  val drain_tty_in : Pervasives.in_channel -> unit
  val drain_tty_out : Pervasives.out_channel -> unit
  val drain_tty_fn : string -> unit
  val flush_tty_input_fd : Cash.fd -> unit
  val flush_tty_input_in : Pervasives.in_channel -> unit
  val flush_tty_input_out : Pervasives.out_channel -> unit
  val flush_tty_input_fn : string -> unit
  val flush_tty_output_fd : Cash.fd -> unit
  val flush_tty_output_in : Pervasives.in_channel -> unit
  val flush_tty_output_out : Pervasives.out_channel -> unit
  val flush_tty_output_fn : string -> unit
  val flush_tty_both_fd : Cash.fd -> unit
  val flush_tty_both_in : Pervasives.in_channel -> unit
  val flush_tty_both_out : Pervasives.out_channel -> unit
  val flush_tty_both_fn : string -> unit
  val start_tty_output_fd : Cash.fd -> unit
  val start_tty_output_in : Pervasives.in_channel -> unit
  val start_tty_output_out : Pervasives.out_channel -> unit
  val start_tty_output_fn : string -> unit
  val stop_tty_output_fd : Cash.fd -> unit
  val stop_tty_output_in : Pervasives.in_channel -> unit
  val stop_tty_output_out : Pervasives.out_channel -> unit
  val stop_tty_output_fn : string -> unit
  val start_tty_input_fd : Cash.fd -> unit
  val start_tty_input_in : Pervasives.in_channel -> unit
  val start_tty_input_out : Pervasives.out_channel -> unit
  val start_tty_input_fn : string -> unit
  val stop_tty_input_fd : Cash.fd -> unit
  val stop_tty_input_in : Pervasives.in_channel -> unit
  val stop_tty_input_out : Pervasives.out_channel -> unit
  val stop_tty_input_fn : string -> unit
  val open_control_tty_in :
    ?flags:Io_3_2.open_flag list -> string -> Pervasives.in_channel
  val open_control_tty_out :
    ?flags:Io_3_2.open_flag list -> string -> Pervasives.out_channel
  val become_session_leader : unit -> int
  val tty_process_group_fd : Cash.fd -> int
  val tty_process_group_in : Pervasives.in_channel -> int
  val tty_process_group_out : Pervasives.out_channel -> int
  val tty_process_group_fn : string -> int
  val set_tty_process_group_fd : Cash.fd -> int -> int
  val set_tty_process_group_in : Pervasives.in_channel -> int -> int
  val set_tty_process_group_out : Pervasives.out_channel -> int -> int
  val set_tty_process_group_fn : string -> int -> int
  val control_tty_file_name : unit -> string
  val fork_pty_session :
    (unit -> unit) ->
    Proc_3_4.proc * Pervasives.in_channel * Pervasives.out_channel * string
  val open_pty : unit -> Pervasives.in_channel * string
  val tty_name_of_pty_name : string -> string
  val pty_name_of_tty_name : string -> string
  val make_pty_generator : unit -> unit -> string
  type socket_domain = Unix.socket_domain = PF_UNIX | PF_INET
  and protocol_family = Cash.socket_domain
  and socket_type =
    Unix.socket_type =
      SOCK_STREAM
    | SOCK_DGRAM
    | SOCK_RAW
    | SOCK_SEQPACKET
  and protocol_level = Network_4.protocol_level = SOL_SOCKET
  and socket = {
    family : Cash.protocol_family;
    sock_in : Pervasives.in_channel;
    sock_out : Pervasives.out_channel;
  } 
  val create_socket :
    ?protocol:int -> Cash.protocol_family -> Cash.socket_type -> Cash.socket
  val create_socket_pair : Cash.socket_type -> Cash.socket * Cash.socket
  val close_socket : Cash.socket -> unit
  type inet_addr = Unix.inet_addr
  val inet_addr_any : Cash.inet_addr
  val inet_addr_loopback : Cash.inet_addr
  val inet_addr_broadcast : Cash.inet_addr
  type sockaddr =
    Unix.sockaddr =
      ADDR_UNIX of string
    | ADDR_INET of Cash.inet_addr * int
  val socket_address_of_unix_address : string -> Cash.sockaddr
  val socket_address_of_internet_address :
    Cash.inet_addr -> int -> Cash.sockaddr
  val sockaddr_of_host_and_port : string -> int -> Cash.sockaddr
  val sockaddr_of_host_and_service : string -> string -> Cash.sockaddr
  val unix_address_of_socket_address : Cash.sockaddr -> string
  val internet_address_of_socket_address :
    Cash.sockaddr -> Cash.inet_addr * int
  val socket_connect : Cash.sockaddr -> Cash.socket_type -> unit
  val bind_listen_accept_loop_unix :
    string -> (Cash.socket -> Cash.sockaddr -> unit) -> unit
  val bind_listen_accept_loop_port :
    int -> (Cash.socket -> Cash.sockaddr -> unit) -> unit
  val bind_listen_accept_loop_service :
    string -> (Cash.socket -> Cash.sockaddr -> unit) -> unit
  val connect_socket : Cash.socket -> Cash.sockaddr -> unit
  val bind_socket : Cash.socket -> Cash.sockaddr -> unit
  val listen_socket : Cash.socket -> int -> unit
  val accept_connection : Cash.socket -> Cash.socket * Cash.sockaddr
  val socket_local_address : Cash.socket -> Cash.sockaddr
  val socket_remote_address : Cash.socket -> Cash.sockaddr
  type shutdown_command =
    Unix.shutdown_command =
      SHUTDOWN_RECEIVE
    | SHUTDOWN_SEND
    | SHUTDOWN_ALL
  val shutdown_socket : Cash.socket -> Cash.shutdown_command -> unit
  type msg_flag = Unix.msg_flag = MSG_OOB | MSG_DONTROUTE | MSG_PEEK
  val receive_message :
    ?flags:Cash.msg_flag list -> Cash.socket -> int -> string * Cash.sockaddr
  val receive_message_bang :
    ?start:int ->
    ?end_:int ->
    ?flags:Cash.msg_flag list -> Cash.socket -> string -> int * Cash.sockaddr
  val receive_message_partial :
    ?flags:Cash.msg_flag list -> Cash.socket -> int -> string * Cash.sockaddr
  val receive_message_bang_partial :
    ?start:int ->
    ?end_:int ->
    ?flags:Cash.msg_flag list -> Cash.socket -> string -> int * Cash.sockaddr
  val send_message :
    ?start:int ->
    ?end_:int ->
    ?flags:Cash.msg_flag list ->
    ?sockaddr:Cash.sockaddr -> Cash.socket -> string -> unit
  val send_message_partial :
    ?start:int ->
    ?end_:int ->
    ?flags:Cash.msg_flag list ->
    ?sockaddr:Cash.sockaddr -> Cash.socket -> string -> int
  type socket_bool_option =
    Unix.socket_bool_option =
      SO_DEBUG
    | SO_BROADCAST
    | SO_REUSEADDR
    | SO_KEEPALIVE
    | SO_DONTROUTE
    | SO_OOBINLINE
    | SO_ACCEPTCONN
  and socket_int_option =
    Unix.socket_int_option =
      SO_SNDBUF
    | SO_RCVBUF
    | SO_ERROR
    | SO_TYPE
    | SO_RCVLOWAT
    | SO_SNDLOWAT
  and socket_optint_option = Unix.socket_optint_option = SO_LINGER
  and socket_float_option =
    Unix.socket_float_option =
      SO_RCVTIMEO
    | SO_SNDTIMEO
  val socket_option_bool :
    Cash.socket -> Cash.protocol_level -> Cash.socket_bool_option -> bool
  val set_socket_option_bool :
    Cash.socket ->
    Cash.protocol_level -> Cash.socket_bool_option -> bool -> unit
  val socket_option_int :
    Cash.socket -> Cash.protocol_level -> Cash.socket_int_option -> int
  val set_socket_option_int :
    Cash.socket ->
    Cash.protocol_level -> Cash.socket_int_option -> int -> unit
  val socket_option_optint :
    Cash.socket ->
    Cash.protocol_level -> Cash.socket_optint_option -> int option
  val set_socket_option_optint :
    Cash.socket ->
    Cash.protocol_level -> Cash.socket_optint_option -> int option -> unit
  val socket_option_float :
    Cash.socket -> Cash.protocol_level -> Cash.socket_float_option -> float
  val set_socket_option_float :
    Cash.socket ->
    Cash.protocol_level -> Cash.socket_float_option -> float -> unit
  type herror =
      HOST_NOT_FOUND
    | TRY_AGAIN
    | NO_RECOVERY
    | NO_DATA
    | NO_ADDRESS
  exception Netdb_error of Cash.herror
  type host_info =
    Unix.host_entry = {
    h_name : string;
    h_aliases : string array;
    h_addrtype : Cash.protocol_family;
    h_addr_list : Cash.inet_addr array;
  } 
  val host_info_name : string -> Cash.host_info
  val host_info_addr : Cash.sockaddr -> Cash.host_info
  type network_info = {
    n_name : string;
    n_aliases : string array;
    n_addrtype : Cash.protocol_family;
    n_net : int32;
  } 
  val network_info_name : string -> Cash.network_info
  val network_info_addr : Cash.sockaddr -> Cash.network_info
  type service_info =
    Unix.service_entry = {
    s_name : string;
    s_aliases : string array;
    s_port : int;
    s_proto : string;
  } 
  val service_info_name : ?protocol:string -> string -> Cash.service_info
  val service_info_port : ?protocol:string -> int -> Cash.service_info
  type protocol_info =
    Unix.protocol_entry = {
    p_name : string;
    p_aliases : string array;
    p_proto : int;
  } 
  val protocol_info_name : string -> Cash.protocol_info
  val protocol_info_port : int -> Cash.protocol_info
  val is_file_name_directory : string -> bool
  val is_file_name_non_directory : string -> bool
  val file_name_as_directory : string -> string
  val directory_as_file_name : string -> string
  val is_file_name_absolute : string -> bool
  val file_name_directory : string -> string
  val file_name_nondirectory : string -> string
  val split_file_name : string -> string list
  val file_name_of_path_list : ?dir:string -> string list -> string
  val file_name_extension : string -> string
  val file_name_sans_extension : string -> string
  val parse_file_name : string -> string * string * string
  val replace_extension : string -> string -> string
  val simplify_file_name : string -> string
  val resolve_file_name : ?dir:string -> string -> string
  val expand_file_name : ?dir:string -> string -> string
  val absolute_file_name : ?dir:string -> string -> string
  val home_dir : ?user:string -> unit -> string
  val home_file : ?user:string -> string -> string
  val substitute_env_vars : string -> string
  val index : ?from:int -> string -> char -> int option
  val rindex : ?from:int -> string -> char -> int option
  val substring : string -> int -> int -> string
  val xsubstring : string -> int -> int -> string
  val is_letter : char -> bool
  val is_lower_case : char -> bool
  val is_upper_case : char -> bool
  val is_title_case : char -> bool
  val is_digit : char -> bool
  val is_letter_or_digit : char -> bool
  val is_graphic : char -> bool
  val is_printing : char -> bool
  val is_whitespace : char -> bool
  val is_blank : char -> bool
  val is_iso_control : char -> bool
  val is_punctuation : char -> bool
  val is_hex_digit : char -> bool
  val is_ascii : char -> bool
  val is_alphabetic : char -> bool
  val is_alphanumeric : char -> bool
  val is_numeric : char -> bool
  type handle_delim = Trim | Peek | Concat
  and termination_kind = Eof | Read of char | Full_buffer
  val read_line :
    ?handle_newline:Cash.handle_delim -> Pervasives.in_channel -> string
  val read_line_split :
    Pervasives.in_channel -> string * Cash.termination_kind
  val read_paragraph :
    ?handle_delim:Cash.handle_delim -> Pervasives.in_channel -> string
  val read_paragraph_split : Pervasives.in_channel -> string * string
  val read_delimited :
    ?chan:Pervasives.in_channel ->
    ?handle_delim:Cash.handle_delim -> Charset_14.any_t -> string
  val read_delimited_split :
    ?chan:Pervasives.in_channel ->
    Charset_14.any_t -> string * Cash.termination_kind
  val read_delimited_bang :
    ?chan:Pervasives.in_channel ->
    ?handle_delim:Cash.handle_delim ->
    ?start:int -> ?end_:int -> Charset_14.any_t -> string -> int option
  val read_delimited_bang_split :
    ?chan:Pervasives.in_channel ->
    ?start:int ->
    ?end_:int ->
    Charset_14.any_t -> string -> (int * Cash.termination_kind) option
  val low_read_delimited_bang :
    ?chan:Pervasives.in_channel ->
    ?start:int ->
    ?end_:int ->
    Charset_14.any_t ->
    string -> Cash.handle_delim -> Cash.termination_kind * int
  val skip_char_set : ?chan:Pervasives.in_channel -> Charset_14.any_t -> int
  val record_reader :
    ?delims:Charset_14.any_t ->
    ?elide_delims:bool ->
    ?handle_delim:Delim_7.handle_delim ->
    unit -> Pervasives.in_channel -> string
  val record_reader_split :
    ?delims:Charset_14.any_t ->
    ?elide_delims:bool -> unit -> Pervasives.in_channel -> string * string
  type handle_field_delim = Trim_f | Split_f | Concat_f
  and delim_matcher =
      Match_proc of (string -> int -> int * int)
    | String of string
    | Charset of Charset_14.any_t
    | Regexp of Pcre.regexp
    | Pattern of string
  val field_splitter :
    ?field:Cash.delim_matcher ->
    ?num_fields:int -> unit -> ?start:int -> string -> string list
  val infix_splitter :
    ?delim:Cash.delim_matcher ->
    ?num_fields:int ->
    ?handle_delim:Cash.handle_field_delim ->
    unit -> ?start:int -> string -> string list
  val suffix_splitter :
    ?delim:Cash.delim_matcher ->
    ?num_fields:int ->
    ?handle_delim:Cash.handle_field_delim ->
    unit -> ?start:int -> string -> string list
  val sloppy_suffix_splitter :
    ?delim:Cash.delim_matcher ->
    ?num_fields:int ->
    ?handle_delim:Cash.handle_field_delim ->
    unit -> ?start:int -> string -> string list
  val default_field_matcher : Cash.delim_matcher
  val default_infix_matcher : Cash.delim_matcher
  val default_suffix_matcher : Cash.delim_matcher
  val field_reader :
    ?field_parser:(?start:int -> string -> string list) ->
    ?rec_reader:(Pervasives.in_channel -> string) ->
    unit -> Pervasives.in_channel -> string * string list
  val default_field_parser : ?start:int -> string -> string list
  val gen_field_reader : ('-> 'b) -> ('-> 'a) -> '-> 'a * 'b
end