  The Mutt Mail Client
  by Michael Elkins <me@cs.hmc.edu>
  v0.48, 18 October 1996

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

  11..  IInnttrroodduuccttiioonn

  Mutt is a small but very powerful curses-based mail client for Unix
  operating systems.  Some of its features include:

  +o  color support

  +o  message threading

  +o  xterm mouse support

  +o  MIME support (including RFC1522 support for encoded headers)

  +o  customizable key bindings

  +o  indefinite postponement of outgoing messages

  +o  POP3 support

  +o  Delivery Status Notification (DSN) support

  +o  PGP/MIME support (US/Canada only)

  The best way to describe this mail user agent (MUA) is to say that
  it's a hybrid, or ``mutt,'' consisting of features from various other
  curses-based e-mail clients.  Its interface is largely based on ELM,
  but hints of PINE and MUSH are also present.  It is nnoott a clone.  Mutt
  has developed a personality of its own.

  11..11..  SSuuppppoorrtteedd ppllaattffoorrmmss

  Mutt has been reported to compile and run under the following Unix
  operating systems:

  +o  AIX

  +o  Convex

  +o  Digital Unix

  +o  FreeBSD

  +o  HP-UX

  +o  Linux

  +o  OSF (DEC Alpha)

  +o  Solaris

  +o  SunOS

  +o  Ultrix

  An ANSI C compiler (such as gcc) is required.  You must also have a
  SysV compatible curses library on your system (if your system does
  not, you should first install the GNU ncurses package
  <ftp://prep.ai.mit.edu/pub/gnu/ncurses-1.9.9e.tar.gz> before compiling
  Mutt).

  11..22..  WWhheerree ttoo ggeett MMuutttt

  Mutt is available from the following FTP sites:

  +o  <ftp://cs.hmc.edu/pub/me> (primary site)

  +o  <ftp://uiarchive.cso.uiuc.edu/pub/packages/mail/mutt>

  +o  <ftp://ftp.ibp.fr/pub/unix/mail/mutt>

  +o  <ftp://ftp.fu-berlin.de/pub/unix/mail/mutt>

  The non-export version, which contains PGP/MIME support, is export
  controlled (it is open to interpretation whether or not the US
  government restricts code of this nature from export under ITAR, so I
  have to cover my ass).  If you are a citizen of the U.S. or Canada,
  please see <ftp://cs.hmc.edu/pub/me/README.US-only> and follow the
  instructions.

  The non-export version has been exported against my wishes, but can
  been found on the following sites:

  +o  <ftp://ftp.teuto.de/pub/user/lmb/>

  +o  <ftp://ftp.fu-berlin.de/pub/unix/mail/mutt/mutt-pgp>

  11..33..  WWhheerree ttoo ggeett mmoorree iinnffoorrmmaattiioonn

  In addition to this manual, there are several other WWW sites which
  contain information on Mutt:

  +o  Mirror of Mutt pages (Thomas Parmelan)
     <http://web.efrei.fr/~parmelan/mutt/>

  +o  Mutt User Information (Sven Guckes) <http://www.math.fu-
     berlin.de/~guckes/mutt/>

  +o  Fefe's Mutt pages (Felix von Leitner) <http://www.math.fu-
     berlin.de/~leitner/mutt/>

  +o  Mutt patches collection (Ollivier Robert) <http://mutt.frmug.org/>

  +o  <ftp://mutt.frmug.org/pub/mutt> (FRANCE)

  +o  <http://freefall.freebsd.org/~roberto> (U.S.)

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

  There are two mailing lists for Mutt.  The first is ``mutt-announce''
  which is a very low traffic list where I post announcents about new
  Mutt releases.  To subscribe, send mail to mutt-announce-
  request@cs.hmc.edu with the word subcribe in the subject.

  The second list is a higher traffic discussion list.  This is where
  patches, bugs and suggestions are posted.  To subscribe to the
  discussion list, send mail to mutt-request@cs.hmc.edu with the word
  subscribe in the subject.  NNoottee::  if you subscribe to the discussion
  list, you do not need to subscribe to ``mutt-announce'' because
  messages are automatically forwarded.

  22..  IInnssttaallllaattiioonn

  Installing Mutt is rather painless through the use of the GNU autoconf
  package <ftp://prep.ai.mit.edu/pug/gnu/autoconf-2.9.tar.gz>.  Simply
  untar the Mutt distribution, and run the configure script.  In most
  cases, it will automatically determine everything it needs to know in
  order to compile.  However, there are a few options to configure to
  help it out, or change the default behavior:

     ----pprreeffiixx==_d_i_r_e_c_t_o_r_y
        install Mutt in _d_i_r_e_c_t_o_r_y instead of /usr/local

     ----wwiitthh--ccuurrsseessiinncclluuddee==_d_i_r_e_c_t_o_r_y
        uses the curses.h found in _d_i_r_e_c_t_o_r_y

     ----wwiitthh--ccuurrsseesslliibb==_d_i_r_e_c_t_o_r_y
        look for libncurses in _d_i_r_e_c_t_o_r_y

     ----wwiitthh--hhoommeessppooooll==_f_i_l_e
        treat _f_i_l_e in the user's home directory as the spool mailbox

     ----ddiissaabbllee--ddoommaaiinn
        force Mutt to not append the FQDN to unqualified addresses

     ----eennaabbllee--ppoopp
        enable POP3 support

     ----eennaabbllee--hhiiddddeenn--hhoosstt
        local hostname is not part of the FQDN.

     ----eennaabbllee--rraannddoomm--ssiigg
        enable the random signature code

     ----eennaabbllee--ddssnn
        enable Delivery Status Notification (DNS) support

     ----eennaabbllee--88bbiittmmiimmee
        enable the use of the -B option to sendmail 8.x

  Once configure has completed, simply type make install.

  Mutt should compile cleanly (without errors) and you should end up
  with a binary called mutt.  If you get errors about undefined symbols
  like A_NORMAL or KEY_MIN, then you probably don't have a SysV
  compliant curses library.  You should install the GNU ncurses package
  <ftp://prep.ai.mit.edu/pub/gnu/ncurses-1.9.9e.tar.gz> and then run the
  configure script again.

  33..  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.

  -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 ] [ -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''.

  44..  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.

  44..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.

  44..22..  CCrreeaattiinngg 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
  (``,'').

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

  44..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.

  44..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 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.  _k_e_y does not need to be
  enclosed in quotes unless it is a space (`` '').  In addition, _k_e_y may
  be one of up, down, left, right, pageup, or pagedown to specify the
  function key of the same name.

  _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

  44..55..  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  status

  +o  subject

  +o  toolbar

  +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

  44..66..  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,
  ``ingore 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.

  44..77..  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.

  44..88..  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

  This 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 to a single message, you should
  either set the ``'' 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.

  44..99..  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.

  44..99..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.

  44..99..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.

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

  44..1100..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.

  44..1100..22..  aallllooww__88bbiitt

  Type: boolean
  Default: unset

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

  44..1100..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.
  44..1100..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.

  44..1100..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.

  44..1100..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.

  44..1100..77..  aasskkmmoovvee

  Type: boolean
  Default: set

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

  44..1100..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.

  44..1100..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.

  44..1100..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 ``''

  44..1100..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.

  44..1100..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''.

  44..1100..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.

  44..1100..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.

  44..1100..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.

  44..1100..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.

  44..1100..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.

  44..1100..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.

  44..1100..1199..  ffoollddeerr

  Type: String
  Default: ~

  Specifies where your mailboxes can be found.

  44..1100..2200..  ffoorrccee__nnaammee

  Type: Boolean
  Default: unset

  When set, Mutt will save outgoing messages in a folder specified by
  the username of the person you are mailing to.  This variable
  overrides the ``record'' variable.

  44..1100..2211..  hhddrr__ffoorrmmaatt

  Type: format string
  Default: "%M %2N %-15.15L (%6c) %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
  %L      list-from function
  %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
  %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
  %u      user (login) name of the author
  %y      last two digits of the year
  %Y      year

  44..1100..2222..  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.

  44..1100..2233..  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.

  44..1100..2244..  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.

  44..1100..2255..  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.

  44..1100..2266..  kkeeeeppssaavvee

  Type: boolean
  Default: unset

  If set, Mutt will _n_o_t delete messages which have been saved to another
  folder.  This causes the ``save'' and ``copy'' commands to become
  identical.

  44..1100..2277..  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''.

  44..1100..2288..  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.

  When set, this causes the _j_u_m_p_-_n_e_w function to position the cursor on
  the first _n_e_w message, which may not be the first _u_n_r_e_a_d message.  If
  unset, jump-new always moves to the first unread message, because the
  distinction between unread and new is ignored.

  44..1100..2299..  mmbbooxx

  Type: String
  Default: +inbox

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

  44..1100..3300..  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.

  44..1100..3311..  ppaaggeerr

  Type: string
  Default: internal

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

  44..1100..3322..  ppaaggeerr__ffmmt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 seqeunces are listed in the ``'' section.

  44..1100..3333..  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.

  44..1100..3344..  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.

  44..1100..3355..  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.

  44..1100..3366..  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.

  44..1100..3377..  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.

  44..1100..3388..  ppoopphhoosstt

  Type: string Default: none

  The name or address of your POP3 server.

  44..1100..3399..  ppooppuusseerr

  Type: string Default: login name on local system

  Your login name on the POP3 server.

  44..1100..4400..  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.

  44..1100..4411..  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.

  44..1100..4422..  pprriinntt

  Type: string
  Default: lpr

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

  44..1100..4433..  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 ``'', 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.

  44..1100..4444..  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.

  44..1100..4455..  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 ``'' variable.

  44..1100..4466..  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.

  44..1100..4477..  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.

  44..1100..4488..  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''.

  44..1100..4499..  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).

  44..1100..5500..  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.

  44..1100..5511..  sshheellll

  Type: string
  Default: retrieved from passwd file

  Command to use when spawning a subshell.

  44..1100..5522..  ssiiggddaasshheess

  Type: boolean
  Default: set

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

  44..1100..5533..  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.

  44..1100..5544..  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.

  44..1100..5555..  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.

  44..1100..5566..  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

  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.

  44..1100..5577..  ssttaattuuss__oonn__ttoopp

  Type: boolean
  Default: unset

  Setting this variable causes the ``'' to be displayed on the first
  line of the screen rather than near the bottom.  This variable has no
  effect when ``'' is set.

  44..1100..5588..  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.

  44..1100..5599..  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.

  44..1100..6600..  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"

  44..1100..6611..  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)'"

  44..1100..6622..  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 ``'' variable.

  44..1100..6633..  xxtteerrmm__mmoouussee

  Type: boolean
  Default: unset

  This variable controls whether or not Mutt will take control of
  interpreting mouse events inside an xterm.  This allows you to use a
  ``toolbar'' inside of Mutt.  Note: you can still use the normal xterm
  cut and paste operations using the <SHIFT> key.

  55..  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 (tag-
  pattern, delete-pattern, etc.).  There are two methods to selecting
  messages.  One is to use a simple range of messages.  For example, to
  select messages one through twenty, you can use:

       Tag messages matching: 1-20

  The other method is to specify a search pattern.  This is similar to
  the syntax of DejaNews, one of the WWW search engines.  Mutt
  understands the following keywords:

  +o  ~s _s_u_b_j_e_c_t -- search for messages having _s_u_b_j_e_c_t in the SUBJECT:
     header field.

  +o  ~t _u_s_e_r -- search for messages addressed to _u_s_e_r

  +o  ~f _u_s_e_r -- search for messages originating from _u_s_e_r

  +o  ~c _u_s_e_r -- search for messages carbon-copied to _u_s_e_r

  To find messages that match more than one criterion, just append
  additional search parameters to your string.  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.

  To do a logical OR operation, use the vertical bar (|).  Example:

       ~t mutt | ~c mutt

  would select all messages which contain the word ``mutt'' in either
  the TO or CC header fields.

  You can also combined AND and OR operations in a single search for
  more complex operations.  AND has precendence over the OR operation,
  so in the following example:

       ~f elkins ~t mutt | ~f elkins ~c mutt

  is grouped logically as follows:

       [ (FROM elkins) AND (TO mutt) ] OR [ (FROM elkins) AND (CC mutt) ]

  66..  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 ``'' 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

     jjuummpp--nneeww
        jump to the first new message in the mailbox

     jjuummpp--uunnrreeaadd
        jump to the first 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

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

  77..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 ``'' and
  authenticate by logging in as ``''.  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 ``''.  After this point, Mutt runs exactly
  as if the mail had always been local.

  77..22..  RRaannddoomm ssiiggnnaattuurreess

  In order to use the random signature feature, you must first enable it
  during compilation.  Edit config.h and make sure that it contains the
  line
       #define ENABLE_RANDOM_SIG

  To use it, first create a file called .sigfixed in your home directory
  and put in there one line that will contain the unchanging part of
  your signature. For example, your name and email address.

  Now, create a directory that will contain the signatures you wish to
  use. I call it .Sig and have it in my home directory, but it can have
  any name as you will specify it in your .muttrc.

  Put the signatures you wish to use in this directory, one per file.
  You can name the files anything you wish as the random signature
  process just grabs one from the directory and doesn't use the name to
  determine which one to grab. For example, my directory contains the
  following files:

       3d              7thDay          EBS             IHS
       Yoda            amnesia         asi             assembly
       atomicBomb      amor            barker          blues
       borg            brains          bugs            burningTree
       catseye         crazy           delenn          dijkstra
       dino            dinosaurs       disney          enhancement
       evolve          fan             germanLoveLife  god
       heard           hippogriff      hoare           hostCoast
       infoHighway     instantCoffee   internet        kalidascope
       kite            kenThompson     knuth           laws
       lawyer          libClue         magic           meek
       memories        memory          novocaine       nuclear
       pace            pentBorg        pizza           poisonIvy
       postman         robin           safety          serene
       snow            starTrekC       styro           terror
       thompson        torture         userFriendly    wrong

  The only restrictions on names are:

  1. Names can't start with a ``..'' (period)

  2. Names can't start with a ``##'' (sharp or pound)

  3. Names can't contain a ``~~'' (tilde)

  Files with names that violate the above restrictions will nnoott be used
  when determining which signature to append.

  Now, edit your .muttrc and add (or change) the following two lines:

       set localsignature=CompletePathToTheDirectoryOfSignatureFiles
       set remotesignature=CompletePathToTheDirectoryOfSignatureFiles

  If you want the same set of signatures for both local and remote mail,
  then you only need to set the signature variable:

       set signature=CompletePathToTheDirectoryOfSignatureFiles

  Because there are two different variables, you can have a different
  set of signatures for local and remote mail. Currently there is only
  one file for the fixed portion of the signature, but that can change
  if it turns out to be needed.

  88..  FFrreeqquueennttllyy AAsskkeedd QQuueessttiioonnss ((FFAAQQss))

  88..11..  WWhhyy ddooeess MMuutttt aauuttoommaattiiccaallllyy eexxiitt tthhee ppaaggeerr??

  Q: Why does Mutt automatically exit the pager without any keypresses
  under Solaris?

  A: The timeout() call in Solaris curses is broken.  Add the following
  line to your  /.muttrc

       set timeout=0

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

  99..11..  WWhhyy MMuutttt??

  You might be wondering what posessed me to write a mail client from
  scratch when ELM and PINE and MH already exist. . .  A little history
  lesson first.  I was a hardcore MUSH (Mail User's SHell) user for many
  years, but gave up on it when it became a commercial product called Z-
  Mail (I like to use ``supported'' software, by which I mean that work
  is still being done on it).

  After that I started using ELM, and I found that I really liked the
  interface.  However, it lacked many features, such as PGP and MIME
  support.  I looked at PINE, but I ditched it because I felt it was too
  oriented toward complete newbies, and I found it ackward and not very
  configurable.  So I went to work hacking on ELM and started out the
  patches that have since been dubbed the ``ELM-ME'' patches.

  While this was going on, work was getting underway in the ELM
  development group for ELM-2.5alpha.  Simply put, the ELM developers
  were not interested in what I was doing, and I became frustrated by
  this because it was obvious from reading comp.mail.elm that many
  people liked what I was doing.  And since ELM is really poorly coded
  in a lot of places, I decided that I would try my hand at writing my
  own mail client from scratch.

  Mutt originally started out as an ELM clone (and to a large extent,
  Mutt still is very ELM-like), but I began thinking of features
  (especially from MUSH) that I really liked and missed.  Also, there
  are many parts of ELM that I was not particulary fond of, or felt
  could have been done better.  As a result, Mutt has ended up having
  very much a personality of its own while remaining easy for ELM users
  to switch over.
  When I first started writing Mutt, I had not really intended for it to
  become as popular as it has.  I wanted a mail client that II liked and
  didn't really care about anything else.  But I've found that quite a
  few people share my impeccable taste.  :-)

  99..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.

  Thomas ``Mike'' Michlmayr <mike@cosy.sbg.ac.at> designed the
  keybinding mechanism.

  Ken Weinert <kenw@ihs.com> wrote the random signature support.

  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>,
  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>,
  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>

  99..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>.

