  The Mutt E-Mail Client
  by Michael Elkins <me@cs.hmc.edu>
  v0.58, 17 January 1997

  ``All mail clients suck.  This one just sucks less.'' -me, circa 1995

  11..  CCoommmmaanndd lliinnee ooppttiioonnss

  Running mutt with no arguments will make Mutt attempt to read your
  spool mailbox.  However, it is possible to read other mailboxes and to
  send messages from the command line as well.

       -a      attach a file to a message
       -c      specify a carbon-copy (Cc) address
       -F      specify an alternate file to read initialization commands
       -f      specify a mailbox to load
       -i      specify a file to include in a message composition
       -n      do not read the system Muttrc
       -p      recall a postponed message
       -s      specify a subject (enclose in quotes if it contains spaces)
       -v      show version number and compile-time definitions
       -z      exit immediately if there are no messages in the mailbox

  To read messages in a mailbox

  mutt [ -nz ] [ -F _m_u_t_t_r_c ] [ -f _m_a_i_l_b_o_x ]

  To compose a new message

  mutt [ -n ] [ -F _m_u_t_t_r_c ] [ -a _f_i_l_e ] [ -c _a_d_d_r_e_s_s ] [ -i _f_i_l_e_n_a_m_e ] [
  -s _s_u_b_j_e_c_t ] _a_d_d_r_e_s_s [ _a_d_d_r_e_s_s ... ]

  Mutt also supports a ``batch'' mode to send prepared messages.  Simply
  redirect input from the file you wish to send.  For example,

  mutt -s "data set for run #2" professor@bigschool.edu < ~/run2.dat

  This command will send a message to ``professor@bigschool.edu'' with a
  subject of ``data set for run #2''.  In the body of the message will
  be the contents of the file ``~/run2.dat''.

  22..  GGeettttiinngg SSttaarrtteedd wwiitthh MMuutttt

  This section is intended as a brief overview of how to use Mutt.
  There are many other features which are described in elsewhere in the
  manual.

  The keybindings described in the section are the defaults as
  distributed.  Your local system administrator may have altered the
  defaults for your site.  You can always type ``?'' in any menu to
  display the current bindings.

  22..11..  MMoovviinngg AArroouunndd iinn MMeennuuss

  Information is presented in menus, very similar to ELM.  Here is a
  table showing the common keys used to navigate menus in Mutt.

  j or Down       move to the next entry
  k or Up         move to the previous entry
  z or PageDn     go to the next page
  Z or PageUp     go to the previous page
  =               jump to the first entry
  *               jump to the last entry
  q               exit the current menu
  ?               list all keybindings for the current menu

  22..22..  RReeaaddiinngg MMaaiill

  Similar to many other mail clients, there are two modes in which mail
  is read in Mutt.  The first is the index of messages in the mailbox,
  which is called the ``main-menu'' in Mutt.  The second mode is the
  display of the message contents.  This is called the ``pager.''

  The next few sections describe the functions provided in each of these
  modes.

  22..22..11..  TThhee MMeessssaaggee IInnddeexx

  J               move to the next message
  K               move to the previous message
  d               delete message
  u               undelete message
  s               save message
  C               copy message
  t               tag message
  F               flag message (mark as important)
  N               mark message as new
  Return          display message
  Tab             jump to the next new message
  v               view MIME attachments
  $               save changes to mailbox
  c               change to a different mailbox
  l               limit display (show messages matching a pattern)
  o               change the current sort method
  /               search for a message
  q               save changes and exit
  x               abort changes and exit
  Control-L       clear and redraw the screen
  Control-T       tag messages matching a patern
  Control-D       delete messages matching a pattern
  Control-U       undelete messages matching a pattern

  22..22..22..  TThhee BBuuiillttiinn PPaaggeerr

  By default, Mutt uses its ``internal-pager'' to display the body of
  messages.  The pager is very similar to the Unix program ``less,''
  though not nearly as featureful.

  Return  go down one line
  Space   display the next page (or next message if at the end of a message)
  -       go back to the previous page
  n       display the next message
  ?       show keybindings
  /       search for a regular expression (pattern)

  In addition, many of the functions from the ``main-menu'' are
  available in the pager, such as ``delete-message'' or ``copy-message''
  (this is one advantage over using an external pager to view messages).

  22..22..33..  MMaaiillbbooxx sshhoorrttccuuttss

  There are a number of built in shortcuts which refer to specific
  mailboxes.  These shortcuts can be used anywhere you are prompted for
  a file or mailbox path.

  +o  ! -- refers to your spool (incoming) mailbox

  +o  > -- refers to your $mbox file

  +o  < -- refers to your $outbox file

  +o  ~ -- refers to your home directory

  +o  = or + -- refers to your $folder directory

  22..22..44..  UUssiinngg TTaaggss

  Some times it is desirable to perform an operation on a group of
  messages all at once rather than one at a time.  An example might be
  to save message to a mailing list to a separate folder, or to delete
  all messages with a given subject.  To tag all messages matching a
  pattern, use the tag-pattern function, which is bound to ``control-T''
  by default.  Or you can select individual messages by hand using the
  ``tag-message'' function, which is bound to ``t'' by default.

  Once you have tagged the desired messages, you can use the ``tag-
  prefix'' operator, which is the ``;'' (semicolon) key by default.
  When the ``tag-prefix'' operator is used, the nneexxtt operation will be
  applied to all tagged messages if that operation can be used in that
  manner.

  22..33..  SSeennddiinngg MMaaiill

  The following bindings are available in the ``main-menu'' for sending
  messages.

  m       compose a new message
  r       reply to sender
  g       reply to all recipients
  f       forward message
  b       bounce (remail) message
  L       reply to mailing list address

  Mutt will then enter the ``send-menu'' and prompt you for the
  recipients to place on the ``To:'' header field.  Next, it will ask
  you for the ``Subject:'' field for the message, providing a default if
  you are replying to or forwarding a message.

  Once you have finished editing the body of your mail message, you are
  returned to the ``send-menu.''  The following options are available:

  t               edit the To field
  c               edit the Cc field
  b               edit the Bcc field
  s               edit the Subject
  f               specify an ``Fcc'' mailbox
  a               attach/detach files to/from the message
  p               select PGP options (US version only)
  P               postpone this message until later
  i               run ispell to check spelling (if available on your system)
  <Return> or y   send the message
  n               abort sending the message
  ?               show help screen

  22..33..11..  AAttttaacchhiinngg FFiilleess

  Files may be attached to your message by using the ``send-attach-
  menu.''  This menu is accessed by pressing ``a'' in the ``send-menu.''

  Once in the send-attach-menu, the following functions are available:

  a       attach a file
  d       detach a file
  s       edit the descripton
  q       exit the send-attach-menu

  33..  CCoonnffiigguurriinngg MMuutttt

  While the default configuration (or ``preferences'') make Mutt usable
  right out of the box, it is often desirable to tailor Mutt to suit
  your own tastes.  When Mutt is first invoked, it will attempt to read
  the ``system'' configuration file (defaults set by your local system
  administrator), unless the ``-n'' command line option is specified.
  This file is typically /usr/local/share/Muttrc or
  /usr/local/lib/Muttrc.  Next, it looks for a file in your home
  directory named .muttrc.  In this file is where you place commands to
  configure Mutt.

  33..11..  SSyynnttaaxx ooff IInniittiiaalliizzaattiioonn FFiilleess

  An initilization file consists of a series of commands, each on its
  own line.  The hash mark, or pound sign (``#''), is used as a
  ``comment'' character.  You can use it to annotate your initialization
  file.  All text after the comment character to the end of the line is
  ignored.  For example,

       my_hdr X-Disclaimer: Why are you listening to me? # This is a comment

  Sometimes it is necessary to make the comment character appear in a
  string.  This can be done by putting a backslash (``\'') in front of
  it.

  It is also possible to substitute the output of a Unix command in an
  initialization file.  This is accomplished by enclosing the command in
  backquotes (``).  For example,

       my_hdr X-Operating-System: `uname -a`

  The output of the Unix command ``uname -a'' will be substituted before
  the line is parsed.  Note that since initialization files are line
  oriented, only the first line of output from the Unix command will be
  substituted.

  33..22..  AAlliiaasseess

  Usage: alias _k_e_y _a_d_d_r_e_s_s [ , _a_d_d_r_e_s_s, ... ]

  It's usually very cumbersome to remember or type out the address of
  someone you are communicating with.  Mutt allows you to create
  ``aliases'' which map a short string to a full address.

  NNoottee:: if you want to create an alias for a group (by specifying more
  than one address), you mmuusstt separate the addresses with a comma
  (``,'').

  To remove an alias or aliases:

  unalias _a_d_d_r [ _a_d_d_r _._._. ]

       alias muttdude me@cs.hmc.edu (Michael Elkins)
       alias theguys manny, moe, jack

  33..33..  SSppeecciiffyy aann aalltteerrnnaattee ee--mmaaiill aaddddrreessss

  Usage: alternates _a_d_d_r_e_s_s [ _a_d_d_r_e_s_s ... ]

  When displaying the contents of a mailbox, Mutt attempts to indicate
  messages which are addressed to you (as opposed to mail from lists).
  Often times you might receive mail at an address that Mutt doesn't
  understand as being yours.  The alternates command allows you to
  specify _a_l_t_e_r_n_a_t_e addresses where you receive mail.

  If your network is such that you can receive mail at any number of
  hosts in a subnetwork, it can be burdensome to list all possible
  addresses.  In this case, you can make use of the wildcard character
  (``*'') to match any possibility.  The wildcard character mmuusstt be the
  first character in the domain part of the address (the part _a_f_t_e_r the
  at sign (``@'').  For example,

       alternates joe@*.bigcompany.com

  This example would make any host in the ``bigcompany.com'' domain
  match.

  33..44..  CChhaannggiinngg tthhee ddeeffaauulltt kkeeyy bbiinnddiinnggss

  Usage: bind _k_e_y _f_u_n_c_t_i_o_n _m_e_n_u

  This command allows you to change the default key bindings (operation
  invoked when pressing a key).  _k_e_y is the key (or key sequence) you
  wish to bind.

  To specify a control character, use the sequence _\_C_x, where _x is the
  letter of the control character (for example, to specify control-A use
  ``\Ca'').  Note that the case of _x as well as _\_C is ignored, so that
  _\_C_A_, _\_C_a_, _\_c_A and _\_c_a are all equivalent.

  In addition, _k_e_y may consist of:

       \t              tab
       \r              carriage return
       \n              newline
       \e              escape
       up              up arrow
       down            down arrow
       left            left arrow
       right           right arrow
       pageup          Page Up
       pagedown        Page Down
       backspace       Backspace
       delete          Delete

  _k_e_y does not need to be enclosed in quotes unless it contains a space
  (`` '').

  _f_u_n_c_t_i_o_n specifies which action to take when _k_e_y is pressed.

  _m_e_n_u specifies in which menu the binding belongs.  The currently
  defined menus are:

  +o  alias-menu

  +o  attach-menu

  +o  folder-menu

  +o  internal-pager

  +o  main-menu

  +o  send-attach-menu

  +o  send-menu

  +o  url-menu

  You will probably only want to customize the bindings for _m_a_i_n_-_m_e_n_u
  and _i_n_t_e_r_n_a_l_-_p_a_g_e_r.

  33..55..  SSeettttiinngg vvaarriiaabblleess bbaasseedd uuppoonn mmaaiillbbooxx

  Usage: folder-hook _p_a_t_t_e_r_n _c_o_m_m_a_n_d

  It is often desirable to change settings based on which mailbox you
  are reading.  The folder-hook command provides a method by which you
  can execute any configuration command.  _p_a_t_t_e_r_n is a regular
  expression specifying which mailboxes to exectute _c_o_m_m_a_n_d for.  If a
  mailbox matches multiple folder-hook's, they are executed in the order
  given in the muttrc.

  33..66..  SSppeecciiffyyiinngg aalltteerrnnaattee llooccaall hhoossttss

  Usage: localsite _a_d_d_r_e_s_s [ _a_d_d_r_e_s_s _._._. ]

  Mutt gives you the ability to use a different signature file based on
  whether you are sending a message to a local organization or to a
  remote site.  The localsite command allows you to specify hosts that
  are to be considered part of your local organization, thus using the
  ``localsignature'' variable.

  33..77..  KKeeyybbooaarrdd mmaaccrrooss

  Usage: macro _m_e_n_u _k_e_y _s_e_q_u_e_n_c_e

  Macros are useful when you would like a single key to perform a series
  of actions.  When you press _k_e_y in menu _m_e_n_u, Mutt will behave as if
  you had typed _s_e_q_u_e_n_c_e.  So if you have a common sequence of commands
  you type, you can create a macro to execute those commands with a
  single key.

  33..88..  UUssiinngg ccoolloorr aanndd mmoonnoo vviiddeeoo aattttrriibbuutteess

  If your terminal supports color, you can spice up Mutt by creating
  your own color scheme.  To define the color of an object (type of
  information), you must specify both a foreground color aanndd a
  background color (it is not possible to only specify one or the
  other).

  Usage: color _o_b_j_e_c_t _f_o_r_e_g_r_o_u_n_d _b_a_c_k_g_r_o_u_n_d

  _o_b_j_e_c_t can be one of:

  +o  attachment

  +o  error

  +o  from

  +o  header

  +o  indicator

  +o  normal

  +o  quoted

  +o  signature

  +o  status

  +o  subject

  +o  tilde

  +o  tree

  _f_o_r_e_g_r_o_u_n_d and _b_a_c_k_g_r_o_u_n_d can be one of the following:

  +o  white

  +o  black

  +o  green

  +o  magenta

  +o  blue

  +o  cyan

  +o  yellow

  +o  red

  _f_o_r_e_g_r_o_u_n_d can optionally be prefixed with the keyword bright to make
  the foreground color boldfaced (e.g., brightred).

  If your terminal does not support color, it is still possible change
  the video attributes through the use of the ``mono'' command:

  Usage: mono _<_o_b_j_e_c_t_> _<_a_t_t_r_i_b_u_t_e_>

  where _a_t_t_r_i_b_u_t_e is one of the following:

  +o  none

  +o  bold

  +o  underline

  +o  reverse

  33..99..  IIggnnoorriinngg ((wweeeeddiinngg)) uunnwwaanntteedd mmeessssaaggee hheeaaddeerrss

  Usage: [un]ignore _p_a_t_t_e_r_n [ _p_a_t_t_e_r_n ... ]

  Messages often have many header fields added by automatic processing
  systems, or which may not seem useful to display on the screen.  This
  command allows you to specify header fields which you don't normally
  want to see.

  You do not need to specify the full header field name.  For example,
  ``ignore content-'' will ignore all header fields that begin with the
  pattern ``content-''.

  To remove a previously added token from the list, use the ``unignore''
  command.  Note that if you do ``ignore x-'' it is not possible to
  ``unignore x-mailer,'' for example.  The ``unignore'' command does nnoott
  make Mutt display headers with the given pattern.

  ``unignore *'' will remove all tokens from the ignore list.

  33..1100..  MMaaiilliinngg lliissttss

  Usage: [un]lists _a_d_d_r_e_s_s [ _a_d_d_r_e_s_s ... ]

  Mutt has quite a few nice features for dealing with mailing lists.  In
  order to take advantage of them, you must tell Mutt which addresses
  belong to mailing lists.

  It is important to note that you should nneevveerr specify the domain name
  ( the part after the ``@'') with the lists command.  You should only
  specify the ``mailbox'' portion of the address (the part before the
  ``@'').  For example, if you've subscribed to the Mutt mailing list,
  you will receive mail addressed to ``mutt@cs.hmc.edu''.  So, to tell
  Mutt that this is a mailing list, you would add ``lists mutt'' to your
  initialization file.

  The ``unlists'' command is to remove a token from the list of mailing-
  lists.  Use ``unlists *'' to remove all tokens.

  33..1111..  UUssiinngg MMuullttiippllee SSppooooll MMaaiillbbooxxeess

  Usage: mbox-hook _p_a_t_t_e_r_n _m_a_i_l_b_o_x

  This command is used to move read messages from a specified mailbox to
  a different mailbox automatically when you quit or change folders.
  _p_a_t_t_e_r_n is a regular expression specifying the mailbox to treat as a
  ``spool'' mailbox and _m_a_i_l_b_o_x specifies where mail should be saved
  when read.

  33..1122..  UUsseerr ddeeffiinneedd hheeaaddeerrss

  Usage:
  my_hdr _s_t_r_i_n_g
  unmy_hdr _f_i_e_l_d [ _f_i_e_l_d ... ]

  The ``my_hdr'' command allows you to create your own header fields
  which will be added to every message you send.

  For example, if you would like to add an ``Organization:'' header
  field to all of your outgoing messages, you can put the command

       my_hdr Organization: A Really Big Company, Anytown, USA

  in your .muttrc.

  If you would like to add a header field to a single message, you
  should either set the ``edit_hdrs'' variable, or use the _e_d_i_t_-_h_e_a_d_e_r_s
  function (default: ``E'') in the send-menu so that you can edit the
  header of your message along with the body.

  To remove user defined header fields, use the ``unmy_hdr'' command.
  You may specify an asterisk (``*'') to remove all header fields, or
  the fields to remove.  For example, to remove all ``To'' and ``Cc''
  header fields, you could use:

       unmy_hdr to cc

  33..1133..  SSppeecciiffyy ddeeffaauulltt ssaavvee ffiilleennaammeess

  Usage: save-hook _a_d_d_r_e_s_s _f_i_l_e_n_a_m_e

  The default filename offered when saving a message to a file may not
  always be correct.  The save-hook command allows you to specify a
  specific folder to save messages in based upon an e-mail address.

  33..1144..  SSeettttiinngg vvaarriiaabblleess

  Usage: [un]set [no]_v_a_r_i_a_b_l_e [ = _v_a_l_u_e ]

  This command is used to set (and unset) ``configuration variables''.
  There are three basic types of variables: boolean, number and string.
  _b_o_o_l_e_a_n variables can be _s_e_t (true) or _u_n_s_e_t (false).  _n_u_m_b_e_r
  variables can be assigned a positive integer value.

  _s_t_r_i_n_g variables consist of any number of printable characters.
  _s_t_r_i_n_g_s must be enclosed in quotes if they contain spaces or tabs.
  You may also use the ``C'' escape sequences \\nn and \\tt for newline and
  tab, respectively.

  Prefixing a boolean variable with ``no'' will unset it (same as the
  _u_n_s_e_t command):

  Example: set noaskbcc.

  Using the enter-command function in the main-menu, you can query the
  value of a variable by prefixing the name of the variable with a
  question mark:

       set ?allow_8bit

  The question mark is actually only required for boolean variables.

  33..1144..11..  SSeelleeccttiinngg tthhee ssoorrttiinngg mmeetthhoodd

  Usage: sort _m_e_t_h_o_d

  Sets the default mode for sorting messages in the message index (main-
  menu).  _m_e_t_h_o_d is allowed to be one of the following:

  +o  date-received

  +o  date-sent

  +o  from

  +o  mailbox-order

  +o  size

  +o  subject

  +o  threads

  For all modes except ``threads'', you may use the prefix ``reverse-''
  to sort in reverse.
  Example: sort reverse-date-sent.

  33..1144..22..  RReeaaddiinngg iinniittiiaalliizzaattiioonn ccoommmmaannddss ffrroomm aannootthheerr ffiillee

  Usage: source _f_i_l_e_n_a_m_e

  This command allows the inclusion of initialization commands from
  other files.  For example, I place all of my aliases in
  ~/.mail_aliases so that I can make my ~/.muttrc readable and keep my
  aliases private.

  If the filename begins with a tilde (``~''), it will be expanded to
  the path of your home directory.

  33..1144..33..  EExxeeccuuttiinngg ssppeecciiffiicc ccoommmmaannddss ffoorr aa mmaaiillbbooxx

  Usage: folder-hook _m_a_i_l_b_o_x _c_o_m_m_a_n_d

  Causes Mutt to execute _c_o_m_m_a_n_d when loading the file specified by
  _m_a_i_l_b_o_x.  If more than one hook is specified, Mutt will execute all
  hooks in the order they appear (although you might want to create a
  file which contains the commands and declare the hook to source it).

  33..1144..44..  SSppeecciiffyyiinngg ddeeffaauulltt ssaavvee mmaaiillbbooxxeess

  Usage: save-hook _a_d_d_r_e_s_s _m_a_i_l_b_o_x

  When saving or copying a message, Mutt will use _m_a_i_l_b_o_x as the default
  filename when the message is From, To or Cc the e-mail address given
  by _a_d_d_r_e_s_s.

  33..1155..  CCoonnffiigguurraattiioonn vvaarriiaabblleess

  33..1155..11..  aalliiaass__ffiillee

  Type: string
  Default: ~/.muttrc

  The default file in which to save aliases created by the ``create-
  alias'' function.

  33..1155..22..  aallllooww__88bbiitt

  Type: boolean
  Default: set

  Controls whether 8-bit data is converted to 7-bit using either Quoted-
  Printable or Base64 encoding when sending mail.

  33..1155..33..  aasskkbbcccc

  Type: boolean
  Default: unset

  If set, Mutt will prompt you for blind-carbon-copy (Bcc) recipients
  before editing an outgoing message.

  33..1155..44..  aasskkcccc

  Type: boolean
  Default: unset

  If set, Mutt will prompt you for carbon-copy (Cc) recipients before
  editing the body of an outgoing message.

  33..1155..55..  aasskkccooppyy

  Type: boolean
  Default: set

  If set, Mutt will ask you if you would like to save a copy of your
  outgoing message.

  33..1155..66..  aasskkddeelleettee

  Type: boolean
  Default: set

  If set, Mutt will confirm that you really want to delete messages when
  closing a mailbox.

  33..1155..77..  aasskkmmoovvee

  Type: boolean
  Default: set

  If the ``hold'' variable is unset, you will be asked to confirm moving
  read messages from your spool mailbox to your ``mbox'' mailbox.

  33..1155..88..  aasskkppoossttppoonnee

  Type: boolean
  Default: set

  If set, you will be asked if you would like to postpone your outgoing
  message if you decide not to send it.

  33..1155..99..  aasskkpprriinntt

  Type: boolean
  Default: set

  Controls whether or not Mutt asks for confirmation before printing.
  This is useful for people (like me) who accidentally hit ``p'' often.

  33..1155..1100..  aasskkrreeccaallll

  Type: boolean
  Default: set

  When set, you will asked if you would like to recall a postponed
  message when you elect to compose a new mail message (only if there
  are messages postponed).  Also see ``postponed''

  33..1155..1111..  aasskkrreeppllyyttoo

  Type: boolean
  Default: unset

  If set, Mutt will ask you if you want to use the address listed in the
  Reply-To header field when replying to a message.  If you answer no,
  it will use the address in the From: header field instead.  This
  option is useful for reading a mailing list that sets the Reply-To
  header field to the list address and you want to send a private
  message to the author of a message.

  33..1155..1122..  aattttrriibbuuttiioonn

  Type: format string
  Default: "On %M %N, %n wrote:"

  This is the string that will precede a message which has been included
  in a reply.  For a full listing of defined escape sequences (%M,
  etc.), see the section on ``hdr_format''.

  33..1155..1133..  aauuttooeeddiitt

  Type: boolean
  Default: unset

  If the ``edit_hdrs'' variable is also set, the initial prompt for
  recipients and subject in the send-menu will be skipped, placing you
  immediately in your editor.

  33..1155..1144..  aauuttooiinncclluuddee

  Type: boolean
  Default: unset

  If set, Mutt will automatically include a copy of the message you are
  replying to instead of asking if you want to.

  33..1155..1155..  ddssnn__nnoottiiffyy

  Type: string
  Default: "failure,delay"

  If Mutt was compile with support for DSN, this variable sets the
  request for when notification is returned.  The string consists of a
  comma separated list (no spaces!) of one or more of the following:
  _n_e_v_e_r, to never request notification, _f_a_i_l_u_r_e, to request notification
  on transmission failure, _d_e_l_a_y, to be notified of message delays,
  _s_u_c_c_e_s_s, to be notified of successful transmission.

  33..1155..1166..  ddssnn__rreettuurrnn

  Type: string Default: "hdrs"

  This variable controls how much of your message is returned in DSN
  messages.  It may be set to either _h_d_r_s to return just the message
  header, or _f_u_l_l to return the full message.

  33..1155..1177..  eeddiitt__hhddrrss

  Type: boolean
  Default: unset

  This option allows you to edit the header of your outgoing messages
  along with the body of your message.

  33..1155..1188..  eeddiittoorr

  Type: String
  Default: value of environment variable $VISUAL, $EDITOR, or "vi"

  This variable specifies which editor to use when composing messages.

  33..1155..1199..  ffcccc__aattttaacchh

  Type: boolean
  Default: set

  This variable controls whether or not attachments on outgoing messages
  are saved along with the main body of your message.

  33..1155..2200..  ffoollddeerr

  Type: String
  Default: ~/Mail

  Specifies where your mailboxes can be found.

  33..1155..2211..  ffoorrccee__nnaammee

  Type: Boolean
  Default: unset

  This variable is similar to ``save_name'', except that Mutt will store
  a copy of your outgoing message by the username of the address you are
  sending to even if that mailbox does not exist.

  Also see the ``record'' variable.

  33..1155..2222..  ffoorrww__ffoorrmmaatt

  Type: format string
  Default: "[%a: %s]"

  This variable controls the default subject when forwarding a message.
  It uses the same format sequences as the ``hdr_format'' variable.

  33..1155..2233..  hhddrr__ffoorrmmaatt

  Type: format string
  Default: "%M %2N %-15.15L (%4l) %s"

  This variable allows you to customize the message index display to
  your personal taste.

  ``Format strings'' are similar to the strings used in the ``C''
  function printf to format output (see the man page for more detail).
  The following sequences are defined in Mutt:
       %a      address of the author
       %c      number of characters (bytes) in the message
       %C      current message number
       %d      date and time of the message
       %f      entire From: line (address + real name)
       %F      entire From: line, unless from self
       %i      message-id of the current message
       %l      number of lines in the message
       %L      list-from function
       %M      three-letter abbreviation for the month
       %m      number of the month (1-12)
       %n      real (personal) name of author
       %N      number of the day of the month
       %s      subject of the message
       %S      status of the message ([New], [Deleted], [Flagged], [Tagged])
       %T      total number of message in the mailbox
       %t      the appropriate character from the ``tochars'' string
       %u      user (login) name of the author
       %y      last two digits of the year
       %Y      year

       %>X     right justify the rest of the string and pad with characater "X"
       %|X     pad to the end of the line with character "X"

  33..1155..2244..  hheeaaddeerr

  Type: boolean
  Default: unset

  When set, this variable causes Mutt to include the _f_u_l_l header of the
  message you are replying to into the edit buffer.

  33..1155..2255..  hhiissttoorryy

  Type: number
  Default: 10

  This variable controls the size (in number of strings remembered) of
  the string history buffer.

  33..1155..2266..  hhoolldd

  Type: boolean
  Default: set

  If set, this causes Mutt nnoott to move read messages from your
  ``spoolfile'' file to your ``mbox'' file.

  33..1155..2277..  iinn__rreeppllyy__ttoo

  Type: format string
  Default: "%i; from \"%n\" on %d"

  This specifies the format of the In-Reply-To: header field added when
  replying to a message.

  33..1155..2288..  kkeeeepp__eemmppttyy

  Type: boolean
  Default: unset

  By default, Mutt will remove any mailboxes which contain zero
  messages.  This variable overrides that default and causes Mutt to
  never remove mailboxes.

  33..1155..2299..  llooccaallssiiggnnaattuurree

  Type: string
  Default: none

  The filename of your signature file which should be copied into the
  message buffer when the recipients are all local.  NNoottee:: setting this
  variable overrides the value of ``signature''.

  33..1155..3300..  mmaarrkk__oolldd

  Type: Boolean
  Default: set

  Controls whether or not Mutt makes the distinction between _n_e_w
  messages and _o_l_d uunnrreeaadd messages.  By default, Mutt will mark new
  messages as old if you exit a mailbox without reading them.  The next
  time you start Mutt, the messages will show up with an "O" next to
  them in the index menu, indicating that they are old.  In order to
  make Mutt treat all unread messages as new only, you can unset this
  variable.

  33..1155..3311..  mmbbooxx

  Type: String
  Default: +inbox

  This specifies the folder into which read mail in your ``spoolfile''
  folder will be appended.

  33..1155..3322..  mmeettoooo

  Type: boolean
  Default: unset

  If set, Mutt will nnoott remove your address from the list of recipients
  when replying to a message.

  33..1155..3333..  mmiimmee__ffwwdd

  Type: boolean
  Default: unset

  When set, the message you are forwarding will be attached as a
  separate MIME part instead of included in the main body of the
  message.  This is useful for forwarding MIME messages so the receiver
  can properly view the message.

  33..1155..3344..  ppaaggeerr

  Type: string
  Default: internal

  This variable specifies which pager you would like to use to view
  messages.

  33..1155..3355..  ppaaggeerr__ccoonntteexxtt

  Type: number
  Default: 0

  This variable controls the number of lines of context that are given
  when displaying the next or previous page in the internal-pager.  By
  default, Mutt will display the line after the last one on the screen
  at the top of the next page (0 lines of context).

  33..1155..3366..  ppaaggeerr__ffoorrmmaatt

  Type: format string
  Default: "%S %C/%T: %-20.20n   %s"

  This variable controls the format of the one-line message ``status''
  displayed before each message in either the internal or an external
  pager.  The valid sequences are listed in the ``hdr_format'' section.

  33..1155..3377..  ppaaggeerr__ssttoopp

  Type: boolean
  Default: unset

  When set, the internal-pager will nnoott move to the next message when
  you are at the end of a message and invoke the _n_e_x_t_-_p_a_g_e function.

  33..1155..3388..  ppggpp

  Type: string
  Default: system dependent

  This variable allows you to override the compile time definition of
  where the PGP binary resides on your system.

  33..1155..3399..  ppggpp__aauuttoossiiggnn

  Type: boolean
  Default: unset

  Setting this variable will cause Mutt to always attempt to PGP/MIME
  sign outgoing messages.  This can be overriden by use of the _p_g_p_-_m_e_n_u,
  when signing is not required or encryption is requested as well.

  33..1155..4400..  ppooiinnttnneeww

  Type: boolean
  Default: set

  This variable controls whether mutt will position you at the first new
  (or unread) message in the mailbox when the mailbox is first opened.

  33..1155..4411..  ppooppddeelleettee

  Type: boolean
  Default: unset

  If set, Mutt will delete successfully downloaded messages from the POP
  server when using the fetch-mail function.  When unset, Mutt will
  download messages but also leave them on the POP server.

  33..1155..4422..  ppoopphhoosstt

  Type: string
  Default: none

  The name or address of your POP3 server.

  33..1155..4433..  ppooppppaassss

  Type: string
  Default: unset

  Specifies the password for you POP account.  If unset, Mutt will
  prompt you for your password when you invoke the fetch-mail function.
  WWaarrnniinngg: you should only use this option when you are on a fairly
  secure machine, because the superuser can read your muttrc even if you
  are the only one who can read the file.

  33..1155..4444..  ppooppppoorrtt

  Type: number
  Default: 110

  This variable specifies which port your POP server is listening on.

  33..1155..4455..  ppooppuusseerr

  Type: string
  Default: login name on local system

  Your login name on the POP3 server.

  33..1155..4466..  ppoosstt__iinnddeenntt__ssttrr

  Type: format string
  Default: none

  Similar to the ``attribution'' variable, Mutt will append this string
  after the inclusion of a message which is being replied to.

  33..1155..4477..  ppoossttppoonneedd

  Type: string
  Default: ~/postponed

  Mutt allows you to indefinitely postpone sending a message which you
  are editing.  When you choose to postpone a message, Mutt saves it in
  the folder specified by this variable.  Also see the ``askpostpone''
  variable.

  33..1155..4488..  pprriinntt

  Type: string
  Default: lpr

  This specifies the command that should be used to print messages.

  33..1155..4499..  pprroommpptt__aafftteerr

  Type: boolean
  Default: set

  If you use an _e_x_t_e_r_n_a_l ``pager'', setting this variable will cause
  Mutt to prompt you for a command when the pager exits rather than
  returning to the index menu.  If unset, Mutt will return to the index
  menu when the external pager exits.

  33..1155..5500..  qquuoottee__rreeggeexxpp

  Type: string
  Default: "^[>|#:}] "

  A regular expression used in internal-pager to determine quoted
  sections of text in the body of a message.

  33..1155..5511..  rreeaaddmmssggiinncc

  Type: number
  Default: 10

  If set to a value greater than 0, mutt will display which message it
  is currently on when reading a mailbox.  The message is printed after
  _r_e_a_d_m_s_g_i_n_c messages have been read (e.g., if set to 25, Mutt will
  print a message when it reads message 25, and then again when it gets
  to message 50).  This variable is meant to indicate progress when
  reading large mailboxes which may take some time.

  When set to 0, only a single message will appear before the reading
  the mailbox.

  Also see the ``writemsginc'' variable.

  33..1155..5522..  rreeaallnnaammee

  Type: string
  Default: GCOS field from /etc/passwd

  This variable specifies what "real" or "personal" name should be used
  when sending messages.

  33..1155..5533..  rreeccoorrdd

  Type: string
  Default: none

  This specifies the file into which your outgoing messages should be
  appended.  This is meant as the primary method for saving a copy of
  your messages, but another way to do this is using the ``my_hdr''
  command to create a _B_c_c_: field with your email address in it.

  Also see the ``force_name'' and ``save_name'' variables.

  33..1155..5544..  rreemmootteessiiggnnaattuurree

  Type: string
  Default: none

  The filename of the signature file which should be appended to the
  message buffer when the destination of the message is a remote host.
  NNoottee:: setting this variable overrides the value of ``signature''.

  33..1155..5555..  rreessoollvvee

  Type: boolean
  Default: set

  When set, the cursor will be automatically advanced to the next
  (possibly undeleted) message whenever a command that modifies the
  current message is executed.

  33..1155..5566..  rreevveerrssee__aalliiaass

  Type: boolean
  Default: unset

  This variable controls whether or not mutt will display the "personal"
  name from your aliases in the index menu if it finds an alias that
  matches the message's sender.  For example, if you have the following
  alias:

  alias juser abd30425@somewhere.net (Joe User)

  and then you receive mail which contains the following header:

  From: abd30425@somewhere.net

  It would be displayed in the index menu as ``Joe User'' instead of
  ``abd30425@somewhere.net.''  This is useful when the person's e-mail
  address is not human friendly (like Compu$erve addresses).

  33..1155..5577..  ssaavvee__nnaammee

  Type: boolean
  Default: unset

  When set, Mutt will check to see if there is mailbox located in your
  ``folder'' directory matching the username of the address to which you
  are sending mail.  If it exists, a copy of your message will be placed
  in that mailbox, otherwise it will be placed in the mailbox specified
  by ``record''.

  Also see the ``force_name'' variable.

  33..1155..5588..  sseennddmmaaiill

  Type: string
  Default: /usr/lib/sendmail

  This variable specifies the path to the program used to deliver your
  outgoing messages.  This allows you to insert a filter between Mutt
  and sendmail, if so desired.
  33..1155..5599..  sshheellll

  Type: string
  Default: retrieved from passwd file

  Command to use when spawning a subshell.

  33..1155..6600..  ssiiggddaasshheess

  Type: boolean
  Default: set

  If set, a line containing ``-- '' will be inserted before your
  ``signature''.  It is strongly recommended that you not unset this
  variable unless your ``signature'' contains just your name.  The
  reason for this is because many software packages use ``-- \n'' to
  detct your signature.  For example, Mutt has the ability to hilite the
  signature in a different color in the internal-pager.

  33..1155..6611..  ssiiggnnaattuurree

  Type: string
  Default: ~/.signature

  Specifies the filename of your signature, which is appended to all
  outgoing messages.  NNoottee::  This variable is overridden by both the
  ``remotesignature'' and ``localsignature'' commands.

  33..1155..6622..  ssppoooollffiillee

  Type: string
  Default: most likely /var/mail/$USER or /usr/spool/mail/$USER

  If your spool mailbox is in a non-default place where Mutt cannot find
  it, you can specify its location with this variable.  Mutt will
  automatically set this variable to the value of the environment
  variable $MAIL if it is set.

  33..1155..6633..  ssttaattuuss__ffoorrmmaatt

  Type: string
  Default: "---Mutt: %f [%M/%m msgs, %n new, %l bytes]---(%s)%|-"

  Controls the format of the status line displayed in the main-menu.
  This string is similar to ``hdr_format'', but has its own set of
  printf()-like sequences:

  %h      local hostname
  %f      the full pathname of the current mailbox
  %l      size (in bytes) of the current mailbox
  %m      the number of messages in the mailbox
  %M      the number of messages shown (i.e., which match the current limit)
  %n      number of new messages in the mailbox
  %p      number of postponed messages
  %s      current sorting mode
  %t      number of tagged messages
  %v      Mutt version string

  %>X     right justify the rest of the string and pad with "X"
  %|X     pad to the end of the line with "X"

  It is also possible to optionally print a variable if it is non-zero.
  For example, you might want to display a message about how many new
  messages there are only if there actually are new messages.  To
  optionally print a variable, use:

  %?...?

  Immediately after the first question mark (?) you should place the
  normal sequence from the above table (_w_i_t_h_o_u_t the %).  You may then
  add an optional string to it.  Here are some examples:

  %?n new? %?t tagged? %?m shown?

  This will print ``N new'' iiff ``N'' is not zero, otherwise it will
  ignore everything between the question marks that surround it.  The
  same goes for the other examples on that line.

  33..1155..6644..  ssttaattuuss__oonn__ttoopp

  Type: boolean
  Default: unset

  Setting this variable causes the ``status_format'' to be displayed on
  the first line of the screen rather than near the bottom.

  33..1155..6655..  ttiillddee

  Type: boolean
  Default: unset

  When set, the internal-pager will pad blank lines to the bottom of the
  screen with a tilde (~).

  33..1155..6666..  ttiimmeeoouutt

  Type: number
  Default: 600

  This variable controls the _n_u_m_b_e_r _o_f _s_e_c_o_n_d_s Mutt will wait for a key
  to be pressed in the main menu before timing out and checking for new
  mail.  A value of zero or less will cause Mutt not to ever time out.

  33..1155..6677..  ttmmppddiirr

  Type: string
  Default: /tmp

  This variable allows you to specify where Mutt will place its
  temporary files needing for displaying and composing messages.

  33..1155..6688..  ttoocchhaarrss

  Type: string
  Default: " +TCF"

  Controls the character used to indicate mail addressed to you.  The
  first character is the one used when the mail is NOT addressed to your
  (default: space).  The second is used when you are the only recipient
  of the message (default: +).  The third is when your address appears
  in the TO header field, but you are not the only recipient of the
  message (default: T).  The fourth character is used when your address
  is specified in the CC header field, but you are not the only
  recipient.  The fifth chacter is used to indicate mail that was sent
  by _y_o_u.

  33..1155..6699..  wweebb__bbrroowwsseerr

  Type: string
  Default: unset

  Command to start a textmode WWW browser on a URL.  This command will
  be invoked by the browse-url function.  The sequence ``%s'' is
  replaced by the URL.  If no ``%s'' is given, the URL will be appended
  to the command.

  Example: set web_browser="lynx %s"

  33..1155..7700..  wweebb__xxbbrroowwsseerr

  Type: string
  Default: unset

  If the environment variable DISPLAY is set, Mutt will assume you are
  running X-windows and use this command to display URL when the browse-
  url function is invoked.  If DISPLAY is not set, browse-url will
  invoke the command named by ``web_browser''.

  Example: set web_xbrowser="netscape -remote 'openURL(%s)'"

  33..1155..7711..  wwrriitteemmssggiinncc

  Type: number
  Default: 10

  When writing a mailbox, a message will be printed every _w_r_i_t_e_m_s_g_i_n_c
  messages to indicate progress.  If set to 0, only a single message
  will be displayed before writing a mailbox.

  Also see the ``readmsginc'' variable.

  44..  SSeeaarrcchhiinngg iinn MMuutttt

  Many of Mutt's commands allow you to specify a pattern to match
  (limit, tag-pattern, delete-pattern, etc.).  There are several ways to
  select messages:

       ~c USER         messages carbon-copied to USER
       ~d MIN-MAX      messages in a Date range
       ~f USER         messages originating from USER
       ~s SUBJECT      messages having SUBJECT in the ``Subject'' field.
       ~t USER         messages addressed to USER
       all             all messages
       flagged         flagged messages
       new             new messages
       old             old messages
       replied         messages which have been replied to
       tagged          tagged messages
       unread          unread messages
       M-N             messages in the range ``M'' through ``N''

  Logical AND is performed by specifying more than one criterion.  For
  example:

       ~t mutt ~f elkins

  would select messages which contain the word ``mutt'' in the list of
  recipients aanndd that have the word ``elkins'' in the ``From'' header
  field.

  Mutt also recognizes the following operators to create more complex
  search patterns:

  +o  ! -- logical NOT operator

  +o  | -- logical OR operator

  +o  () -- logical grouping operator

  Here is an example illustrating a complex search pattern.  This
  pattern will select all messages which do not contain ``mutt'' in the
  ``To'' or ``Cc'' field and which are from ``elkins''.

       !(~t mutt|~c mutt) ~f elkins

  44..11..  SSeeaarrcchhiinngg bbyy DDaattee

  All dates mmuusstt be in DD/MM/YY format (month and year are optional,
  defaulting to the current month and year).  An example of a valid
  range of dates is:

       Limit to messages matching: ~d 20/1/95-31/10

  If you omit the minimum (first) date, and just specify ``-DD/MM/YY'',
  all messages _b_e_f_o_r_e the given date will be selected.  If you omit the
  maximum (second) date, and specify ``DD/MM/YY-'', all messages _a_f_t_e_r
  the given date will be selected.  If you specify a single date with no
  dash (``-''), only messages sent on the given date will be selected.

  55..  mmaaiinn--mmeennuu ffuunnccttiioonnss

  The following is a table of functions defined in the ``main-menu.''  A
  feature of Mutt is that you can change which function is invoked for a
  given key using the ``bind'' command.  To display the current key
  bindings, simply press ``?'' in the ``main-menu'' (you will be
  prompted for a specific key you are interested in, or you may type
  ``?'' again to display all bindings for the menu).

     ddeelleettee--ppaatttteerrnn
        delete message matching a pattern

     uunnddeelleettee--ppaatttteerrnn
        undelete message matching a pattern

     lliimmiitt
        only show messages matching a pattern

     ttaagg--mmeessssaaggee
        tag a message

     ttaagg--ppaatttteerrnn
        tag messages matching a pattern

     uunnttaagg--mmeessssaaggee
        untag a message

     uunnttaagg--ppaatttteerrnn
        untag messages matching a pattern

     ffiirrsstt--mmeessssaaggee
        jump to the first message in the mailbox

     llaasstt--mmeessssaaggee
        jump to the last message in the mailbox

     qquuiitt
        save changes and exit mutt

     ssoorrtt--mmeessssaaggeess
        change the current sorting method

     jjuummpp
        jump to a specific message number

     nneexxtt--ppaaggee
        display the next page of messages

     pprreevviioouuss--ppaaggee
        display the previous page of message

     ssyynncc--mmaaiillbbooxx
        save mailbox changes to disk

     sseeaarrcchh
        search for a specific message

     hheellpp
        get help for the current menu

     rreeddrraaww--ssccrreeeenn
        clear and redraw the screen

     ffoorrggeett--ppaasssspphhrraassee
        wipe PGP passphrase from memory

     ffeettcchh--mmaaiill
        connect to POP3 server and get new mail

     ttoopp--ooff--ppaaggee
        move to the top of the current page

     mmiiddddllee--ooff--ppaaggee
        move to the middle of the page

     bboottttoomm--ooff--ppaaggee
        move to the bottom of the page

     eenntteerr--ccoommmmaanndd
        enter a initialization command

     iinnvvookkee--ssuubbsshheellll
        shell out of Mutt to a prompt

     eexxiitt
        abort changes and exit Mutt

     rreeccaallll--mmeessssaaggee
        resume a postponed message

     nneexxtt--nneeww
        jump to the next new message in the mailbox

     nneexxtt--uunnrreeaadd
        jump to the next unread message

     ddeelleettee--tthhrreeaadd
        delete all messages in the current thread

     nneexxtt--tthhrreeaadd
        move to the next threa

     pprreevviioouuss--tthhrreeaadd
        move to the previous thread

     bbrroowwssee--uurrll
        pull up a list of all URLs in the current message

     ffllaagg--mmeessssaaggee
        mark a message as important

     mmaarrkk--aass--nneeww
        mark the current message as new

     ccrreeaattee--aalliiaass
        create an alias for the author of the current message

     bboouunnccee--mmeessssaaggee
        remail a message

     mmaaiill
        compose a new mail message

     rreeppllyy
        reply to a message(s)

     ggrroouupp--rreeppllyy
        reply to all recipients of a message

     ffoorrwwaarrdd--mmeessssaaggee
        forward a message with comments

     lliisstt--rreeppllyy
        reply to any mailing list addresses in the message

     ddiissppllaayy--mmeessssaaggee
        show the current message

     ddiissppllaayy--hheeaaddeerrss
        show the current message with all headers (no weeding)

     vviieeww--aattttaacchhmmeennttss
        show a list of all MIME attachments in the current message

     cchhaannggee--ffoollddeerr
        open a different mailbox

     nneexxtt--uunnddeelleetteedd
        jump to the next undeleted message

     nneexxtt--mmeessssaaggee
        move to the next message

     pprreevviioouuss--uunnddeelleettee
        move to the last undeleted message

     pprreevviioouuss--mmeessssaaggee
        move to the previous message

     ddeelleettee--mmeessssaaggee
        mark the current message deleted

     uunnddeelleettee--mmeessssaaggee
        undelete the current message

     ssaavvee--mmeessssaaggee
        save message(s) to another mailbox and mark as deleted

     ccooppyy--mmeessssaaggee
        copy message(s) to another mailbox

     pprriinntt--mmeessssaaggee
        print the current message

     ppiippee--mmeessssaaggee
        send a message to a Unix command

  66..  OOppttiioonnaall ffeeaattuurreess

  66..11..  PPOOPP33 ssuuppppoorrtt

  If Mutt was compiled with POP3 support (by running the _c_o_n_f_i_g_u_r_e
  script with the _-_-_e_n_a_b_l_e_-_p_o_p flag), it has the ability to fetch your
  mail from a remote server for local browsing.  When you invoke the
  _f_e_t_c_h_-_m_a_i_l function (default: G), Mutt attempts to connect to
  ``pophost'' and authenticate by logging in as ``popuser''.  After the
  connection is established, you will be prompted for your password on
  the remote system.

  Once you have been authenticated, Mutt will fetch all your new mail
  and place it in the local ``spoolfile''.  After this point, Mutt runs
  exactly as if the mail had always been local.

  77..  MMiisscceellllaannyy

  77..11..  CCooppyyrriigghhtt

  Mutt is Copyright (C) 1996,1997 Michael R. Elkins <me@cs.hmc.edu>

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or (at
  your option) any later version.

  This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  77..22..  AAcckknnoowwlleeddggeemmeennttss

  Kari Hurrta <kari.hurtta@fmi.fi> co-developed the original MIME
  parsing code back in the ELM-ME days.

  The following people have been helpful to the development of Mutt:

  Francois Berjon <Francois.Berjon@aar.alcatel-alsthom.fr>,
  Aric Blumer <aric@fore.com>,
  John Capo <jc@irbs.com>,
  Liviu Daia <daia@stoilow.imar.ro>,
  David DeSimone <fox@convex.hp.com>,
  Nickolay N. Dudorov <nnd@wint.itfs.nsk.su>,
  Michael Finken <finken@conware.de>,
  Sven Guckes <guckes@math.fu-berlin.de>,
  Mark Holloman <holloman@nando.net>,
  Andreas Holzmann <holzmann@fmi.uni-passau.de>,
  David Jeske <jeske@igcom.net>,
  Christophe Kalt <kalt@hugo.int-evry.fr>,
  Felix von Leitner (a.k.a ``Fefe'') <leitner@math.fu-berlin.de>,
  Brandon Long <blong@uiuc.edu>,
  Lars Marowsky-Bree <lmb@pointer.in-minden.de>,
  Thomas ``Mike'' Michlmayr <mike@cosy.sbg.ac.at>,
  David O'Brien <obrien@Nuxi.cs.ucdavis.edu>,
  Clint Olsen <olsenc@ichips.intel.com>,
  Park Myeong Seok <pms@romance.kaist.ac.kr>,
  Thomas Parmelan <tom@ankh.fr.eu.org>,
  Ollivier Robert <roberto@keltia.freenix.fr>,
  Allain Thivillon <Allain.Thivillon@alma.fr>,
  Ken Weinert <kenw@ihs.com>

  77..33..  AAbboouutt tthhiiss ddooccuummeenntt

  This document was written in SGML, and then rendered using the
  LinuxDoc-SGML package.  For more information, see the LinuxDoc-SGML
  Home Page <http://www.informatik.tu-muenchen.de/~schwarz/linuxdoc-
  sgml>.

