diff --git a/README b/README
index 528b539..99d1aeb 100644
--- a/README
+++ b/README
@@ -13,10 +13,10 @@
 --------------------
 1. libdbm
 
-arpd needs to have the db4 development libraries. For debian
+arpd needs to have the db4 development libraries. For Debian
 users this is the package with a name like libdb4.x-dev.
 DBM_INCLUDE points to the directory with db_185.h which
-is the include file used by arpd to get to the old format Berkely
+is the include file used by arpd to get to the old format Berkeley
 database routines.  Often this is in the db-devel package.
 
 2. make
diff --git a/README.distribution b/README.distribution
index fe78fb4..4e2e8ea 100644
--- a/README.distribution
+++ b/README.distribution
@@ -40,7 +40,7 @@
 
 How can we create this table in practice? In some cases, F may have a
 simple expression which allows evaluating its inverse directly.  The
-pareto distribution is one example of this.  In other cases, and
+Pareto distribution is one example of this.  In other cases, and
 especially for matching an experimentally observed distribution, it's
 easiest simply to create a table for F and "invert" it.  Here, we give
 a concrete example, namely how the new "experimental" distribution was
diff --git a/README.iproute2+tc b/README.iproute2+tc
index edd79c0..6aa5d18 100644
--- a/README.iproute2+tc
+++ b/README.iproute2+tc
@@ -45,7 +45,7 @@
 papers. 
 
 
-Pairs X:Y are class handles, X:0 are qdisc heandles.
+Pairs X:Y are class handles, X:0 are qdisc handles.
 weight should be proportional to rate for leaf classes
 (I choosed it ten times less, but it is not necessary)
 
diff --git a/RELNOTES b/RELNOTES
deleted file mode 100644
index 17f0011..0000000
--- a/RELNOTES
+++ /dev/null
@@ -1,168 +0,0 @@
-[020116]
-! 1. Compile with rh-7.2
-! 2. What the hell some people blame on socklen_t defined in unistd.h? Check.
- * Kim Woelders <kim@woelders.dk>, various useful fixups: compilation
-   with old kernels, cross-compiling, "all" == "any" in prefix spec. 
- * Collected from my disk, cleaned and packed to directory iproute2/misc/
-   several utilities: ss, nstat, ifstat, rtacct, arpd and module tcp_diag.
-   Writing some docs. me.
- * prepared patchlet for pidentd to use tcp_diag.
- * David Miller: 64bit (and even worse 64bit kernel/32 bit user :-) fixes
-   to above. tcp_diag is merged to main tree.
- * Alexandr D. Kanevskiy <kad@blackcatlinux.com>: various flaws in ss
- * Alexandr D. Kanevskiy <kad@blackcatlinux.com>: oops, more aggressive caching
-   of names opened old bugs: ip started to print garbage in some places.
- * Robert Olsson, rt_cache_stat. Renamed to rtstat.
- * An old bug in "ip maddr ls": reduntant empty lines in output.
-   Seeing this crap for ages but lucky match of desire/ability to repair
-   and a huff about this happened only today. :-)
- * "Mr. James W. Laferriere" <babydr@baby-dragons.com>
-   doc: option to produce ps output for non-a4 and not only 2 pages/sheet. 
- * Jamal's patch for ingres qdisc.
- * Bernd Eckenfels <ecki@lina.inka.de>: deleted orphaned bogus #include
-   in include/utils.h.
- * Julian Anastasov <ja@ssi.bg>: uninitialized fields in nexthop
-   producing funny "dead" nexthops in multipath routes.
-   Stupid me, look at the first line in [010803]... Was it difficult to guess
-   this that time? People blame for several months. :-)
-   Special thanks to bert hubert <ahu@ds9a.nl> who raised the issue in netdev.
-   Thanks and apologies to Terry Schmidt <terry@nycwireless.net>,
-   Ruben Puettmann <ruben.puettmann@freenet-ag.de>,
-   Mark Ivens <mivens@clara.net>.
- * willy tarreau <wtarreau@yahoo.fr>: "make install" target.
- * Tunable limit for sch_sfq. Patch to kernel activating this
-   is about to be submitted. Reminded by Adi Nugroho <Adi@iNterNUX.co.id>.
-
-[010824]
- * ip address add sets scope of loopback addreses to "host".
-   Advised by David Miller.
- * ZIP! <zip@killerlabs.com> and David Ford <david@blue-labs.org>
-   Some strcpy's changed to strncpy's.
- * David Ford <david@blue-labs.org>, test for compilation with gcc3.
- * David Ford <david@blue-labs.org>. Damn, I broke rtnl_talk in previous
-   snapshot.
-
-[010803]
- * If "dev" is not specified in multipath route, ifindex remained
-   uninitialized. Grr. Thanks to Kunihiro Ishiguro <kunihiro@zebra.org>.
- * Rafal Maszkowski <rzm@icm.edu.pl>, batch mode tc. The most old patch.
- * Updates list of data protocol ids.
-   Lots of reporters. I bring my apologies.
- * Jan Rekorajski <baggins@sith.mimuw.edu.pl>. Updated list of datalink types. 
- * Christina Chen <chenchristina@cwc.nus.edu.sg>. Bug in parsing IPv6 address match in u32. 
- * Pekka Savola <pekkas@netcore.fi>. ip -6 route flush dev lo stuck
-   on deleting root of the table.
- * Werner. dsmark fixes.
- * Alexander Demenshin <aldem-reply@aldem.net>. Old miracleous bug
-   in ip monitor. It was puzzle, people permanently blame that
-   it prints some crap.
- * Rui Prior <rprior@inescporto.pt>. f_route failed to resolve fromif.
-   Werner also noticed this and sent patch. Bad place... [RETHINK]
- * Kim Woelders <kim@woelders.dk>. 
-   - changes in Makefile for cross-compile
-   - understand "all" as alias for "any"
-   - bug in iprule.c
-!  [ NB. Also he sent patch for kernel. Do not forget! ]
- * Werner. Fix to tc core files: wrong exits etc.
- * Bernd Jendrissek <berndj@prism.co.za>. Some sanitizations of tc.c
-!* Marian Jancar <marian.jancar@infonet.cz>. He say q_tbf prints wrong latency!
-!  Seems, he is wrong.
- * Werner (and Nikolai Vladychevski <niko@isl.net.mx>) check ->print_copts
-   to avoid segfault.
-
-[001007]
-  * Compiles under rh-7.0
-
-[000928]
-  * Sorry. I have lost all the CVS with changes made since 000305.
-    If someone sent me a patch after this date, please, resubmit.
-    Restored from the last backup and mailboxes:
-
-  * Edit ip-cref.tex by raf <raf2@zip.com.au>.
-  * RTAX_REORDERING support.
-  * IFLA_MASTER support.
-  * Bug in rtnl_talk(), libnetlink.c. Reported by David P. Olshfski
-	<olshef@us.ibm.com>
-
-[000305]
-  * Bugs in RESOLVE_HOSTNAMES. Bratislav Ilich <bilik@@zepter.ru>
-  * ARPHRD_IEEE802_TR
-
-[000225]
-  * ECN in q_red.c.
-
-[000221]
-  * diffserv update from Jamal Hadi Salim
-  * Some bits of IPX from Steve Whitehouse.
-  * ATM qdisc from Werner Almesberger
-  * Support for new attributes on routes in linux-2.3.
-
-[991023]
-  No news, only several bugs are fixed.
-  * Since ss990630 "ip rule list" printed wrong prefix length.
-      Vladimir V. Ivanov <vlad@alis.tusur.ru>
-  * "ip rule" parsed >INT_MAX values of metric incorrectly.
-      Matthew G. Marsh <mgm@paktronix.com>
-  * Some improvements in doc/Makefile advised by
-      Andi Kleen and Werner Almesberger.
-
-[990824]
-  * new attributes in "ip route": rtt, rttvar, cwnd, ssthresh and advmss.
-  * some updates in documentaion to reflect new status.
-
-[990630]
-  * DiffServ support.
-	Werner Almesberger <almesber@lrc.di.epfl.ch>
-	Jamal Hadi Salim <hadi@nortelnetworks.com> 
-  * DECnet support.
-	Steve Whitehouse <SteveW@ACM.org>
-  * Some minor tweaks in docs and code.
-
-[990530]
-  * routel script. Stephen R. van den Berg <srb@cuci.nl>
-  * Bug in tc/q_prio.c resetting priomap. Reported by
-	Ole Husgaard <sparre@login.dknet.dk> and
-	Jan Kasprzak <kas@informatics.muni.cz>
-  * IP command reference manual is published (ip-cref.tex).
-    I am sorry, but tc-cref.tex is still not ready, to be more
-    exact the draft does not describe current tc 8-)
-  * ip, rtmon, rtacct utilities are updated according to manual 8-)
-    Lots of changes:
-	- (MAIN) "flush" command for addr, neigh and route.
-	- error messages are sanitized; now it does not print
-	  usage() page on each error.
-	- output format is improved.
-	- "oneline" mode is added.
-	- etc.
-  * Name databases; resolution acsii <-> numeric is split out to lib/*
-  * scripts ifcfg, ifone and rtpr.
-  * examples/dhcp-client-script is copied from my patch to ISC dhcp.
-  * Makefile in doc/ directory.
-
-[990417]
-  * "pmtudisc" flag to "ip tunnel". Phil Karn <karn@ka9q.ampr.org>
-  * bug in tc/q_tbf.c preventing setting peak_rate, Martin Mares <mj@ucw.cz>
-  * doc/flowlabels.tex
-
-[990329]
-
-  * This snapshot fixes some compatibility problems, which I introduced
-    occasionally to previous snapshots.
-  * Namely, "allot" to "tc qdisc add ... cbq" is accepted but ignored.
-  * Another changes are supposed to be shown in the next snapshot, but
-    because of troubles with "allot" I am forced to release premature
-    version. Namely, "cell", "prio", "weight" etc. are optional now.
-  * doc/ip-tunnels.tex
-
-[990327]
-  * History was not recorded.
-
-[981002]
-  * Rani Assaf <rani@magic.metawire.com> contributed resolving
-    addresses to names.
-	BEWARE! DO NOT USE THIS OPTION, WHEN REPORTING BUGS IN
-	IPROUTE OR IN KERENEL. ALL THE BUG REPORTS MUST CONTAIN
-	ONLY NUMERIC ADDRESSES.
-
-[981101]
-  * now it should compile for any libc.
