-----------------------------------

GNU Make development starting with GNU Make 3.76 by:
    Paul D. Smith <psmith@gnu.org>

    Additional development starting with GNU Make 4.3 by:
        Dmitry Goncharov <dgoncharov@users.sf.net>

    Additional development starting with GNU Make 3.81 by:
        Boris Kolpackov <boris@kolpackov.net>

GNU Make development up to version 3.75 by:
    Roland McGrath <roland@gnu.org>

GNU Make User's Manual
  Written by:
    Richard M. Stallman <rms@gnu.org>

  Edited by:
    Roland McGrath <roland@gnu.org>
    Bob Chassell <bob@gnu.org>
    Melissa Weisshaus <melissa@gnu.org>
    Paul D. Smith <psmith@gnu.org>

-----------------------------------
GNU Make porting efforts:

  Port to VMS by:
      Klaus Kaempf <kkaempf@progis.de>
      Hartmut Becker <Hartmut.Becker@hp.com>
      Archive support/Bug fixes by:
        John W. Eaton <jwe@bevo.che.wisc.edu>
        Martin Zinser <zinser@decus.decus.de>

  Port to MS-Windows (native/MinGW) maintained by:
      Eli Zaretskii <eliz@gnu.org>

  Port to MS-DOS (DJGPP), OS/2, and MS-Windows (native/MinGW) by:
      DJ Delorie <dj@delorie.com>
      Rob Tulloh <rob_tulloh@tivoli.com>
      Eli Zaretskii <eliz@gnu.org>
      Jonathan Grant <jg@jguk.org>
      Andreas Beuning <andreas.buening@nexgo.de>
      Earnie Boyd <earnie@uses.sf.net>
      Troy Runkel <Troy.Runkel@mathworks.com>
      Juan M. Guerrero <juan.guerrero@gmx.de>
      KO Myung-Hun <komh78@gmail.com>

  Port to z/OS by:
      Igor Todorovski <itodorov@ca.ibm.com>

-----------------------------------
Other contributors:

  Luke Allardyce <lukeallardyce@gmail.com>
  Costas Argyris <costas.argyris@gmail.com>
  Aron Barath <baratharon@caesar.elte.hu>
  David Boyce <dsb@boyski.com>
  Kevin Buettner <kevinb@redhat.com>
  Janet Carson <janet_carson@tivoli.com>
  Howard Chu <hyc@highlandsun.com>
  Ludovic Courtès <ludo@gnu.org>
  Joe Crayne <oh.hello.joe@gmail.com>
  Jeremy Devenport <jeremy.devenport@gmail.com>
  Pete Dietl <petedietl@gmail.com>
  Aaron Digulla <digulla@fh-konstanz.de>
  Hannes Domani <ssbssa@yahoo.de>
  Martin Dorey <martin.dorey@hds.com>
  Christian Eggers <ceggers@arri.de>
  Paul Eggert <eggert@twinsun.com>
  Mike Frysinger <vapier@gentoo.org>
  Ramon Garcia Fernandez <ramon.garcia.f@gmail.com>
  Noah Goldstein <goldstein.w.n@gmail.com>
  Mike Haboustak <haboustak@gmail.com>
  Frank Heckenbach <f.heckenbach@fh-soft.de>
  Klaus Heinz <kamar@ease.rhein-main.de>
  Ben Hutchings <ben@decadent.org.uk>
  Cao jin <caoj.fnst@cn.fujitsu.com>
  Michael Joosten
  Christian Jullien <eligis@orange.fr>
  Jim Kelton <jim_kelton@tivoli.com>
  Kaz Kylheku <kaz@kylheku.com>
  David Lubbren <uhay@rz.uni-karlsruhe.de>
  Tim Magill <tim.magill@telops.gte.com>
  Markus Mauhart <qwe123@chello.at>
  Greg McGary <greg@mcgary.org>
  Thien-Thi Nguyen <ttn@gnuvola.org>
  Han-Wen Nienhuys <hanwen@cs.uu.nl>
  Enrique Olaizola <enrique_olaizola16@hotmail.com>
  Ola Olsson <ola1olsson@gmail.com>
  Jens Rehsack <sno@netbsd.org>
  Thomas Riedl <thomas.riedl@siemens.com>
  Jaak Ristioja <jaak@ristioja.ee>
  Christoph Schulz <develop@kristov.de>
  Andreas Schwab <schwab@suse.de>
  spagoveanu <spagoveanu@gmail.com>
  Carl Staelin (Princeton University)
  Ian Stewartson (Data Logic Limited)
  Tobias Stoeckmann <tobias@stoeckmann.org>
  Torbjörn Svensson <torbjorn.svensson@foss.st.com>
  Sergei Trofimovich <siarheit@google.com>
  Justine Tunney <jtunney@gmail.com>
  Marc Ullman <marc@mathworks.com>
  Christof Warlich <cwarlich@gmx.de>
  Florian Weimer <fweimer@redhat.com>
  David A. Wheeler <dwheeler@dwheeler.com>
  Bernhard M. Wiedemann <bwiedemann@suse.de>
  Ben Wijen <ben@wijen.net>
  Jouke Witteveen <j.witteveen@gmail.com>

With suggestions/comments/bug reports from a cast of ... well ...
hundreds, anyway :)

-------------------------------------------------------------------------------
Copyright (C) 1997-2025 Free Software Foundation, Inc.
This file is part of GNU Make.

GNU Make 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 3 of the License, or (at your option) any later
version.

GNU Make 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, see <https://www.gnu.org/licenses/>.
