diff --git a/Lib/cgi.py b/Lib/cgi.py
index 01a28fe..93747ce 100755
--- a/Lib/cgi.py
+++ b/Lib/cgi.py
@@ -15,9 +15,6 @@
 written in Python.
 """
 
-# XXX Perhaps there should be a slimmed version that doesn't contain
-# all those backwards compatible and debugging classes and functions?
-
 # History
 # -------
 #
@@ -43,8 +40,7 @@
 import collections
 from io import StringIO
 
-__all__ = ["MiniFieldStorage", "FieldStorage", "FormContentDict",
-           "SvFormContentDict", "InterpFormContentDict", "FormContent",
+__all__ = ["MiniFieldStorage", "FieldStorage",
            "parse", "parse_qs", "parse_qsl", "parse_multipart",
            "parse_header", "print_exception", "print_environ",
            "print_form", "print_directory", "print_arguments",
@@ -777,124 +773,6 @@
         return tempfile.TemporaryFile("w+", encoding="utf-8", newline="\n")
 
 
-
-# Backwards Compatibility Classes
-# ===============================
-
-class FormContentDict(collections.Mapping):
-    """Form content as dictionary with a list of values per field.
-
-    form = FormContentDict()
-
-    form[key] -> [value, value, ...]
-    key in form -> Boolean
-    form.keys() -> [key, key, ...]
-    form.values() -> [[val, val, ...], [val, val, ...], ...]
-    form.items() ->  [(key, [val, val, ...]), (key, [val, val, ...]), ...]
-    form.dict == {key: [val, val, ...], ...}
-
-    """
-    def __init__(self, environ=os.environ, keep_blank_values=0, strict_parsing=0):
-        self.dict = self.data = parse(environ=environ,
-                                      keep_blank_values=keep_blank_values,
-                                      strict_parsing=strict_parsing)
-        self.query_string = environ['QUERY_STRING']
-
-    def __len__(self):
-        return len(self.dict)
-
-    def __iter__(self):
-        return iter(self.dict)
-
-    def __getitem__(self, key):
-        return self.dict[key]
-
-
-class SvFormContentDict(FormContentDict):
-    """Form content as dictionary expecting a single value per field.
-
-    If you only expect a single value for each field, then form[key]
-    will return that single value.  It will raise an IndexError if
-    that expectation is not true.  If you expect a field to have
-    possible multiple values, than you can use form.getlist(key) to
-    get all of the values.  values() and items() are a compromise:
-    they return single strings where there is a single value, and
-    lists of strings otherwise.
-
-    """
-    def __getitem__(self, key):
-        if len(self.dict[key]) > 1:
-            raise IndexError('expecting a single value')
-        return self.dict[key][0]
-    def getlist(self, key):
-        return self.dict[key]
-    def values(self):
-        result = []
-        for value in self.dict.values():
-            if len(value) == 1:
-                result.append(value[0])
-            else: result.append(value)
-        return result
-    def items(self):
-        result = []
-        for key, value in self.dict.items():
-            if len(value) == 1:
-                result.append((key, value[0]))
-            else: result.append((key, value))
-        return result
-
-
-class InterpFormContentDict(SvFormContentDict):
-    """This class is present for backwards compatibility only."""
-    def __getitem__(self, key):
-        v = SvFormContentDict.__getitem__(self, key)
-        if v[0] in '0123456789+-.':
-            try: return int(v)
-            except ValueError:
-                try: return float(v)
-                except ValueError: pass
-        return v.strip()
-    def values(self):
-        result = []
-        for key in self.keys():
-            try:
-                result.append(self[key])
-            except IndexError:
-                result.append(self.dict[key])
-        return result
-    def items(self):
-        result = []
-        for key in self.keys():
-            try:
-                result.append((key, self[key]))
-            except IndexError:
-                result.append((key, self.dict[key]))
-        return result
-
-
-class FormContent(FormContentDict):
-    """This class is present for backwards compatibility only."""
-    def values(self, key):
-        if key in self.dict :return self.dict[key]
-        else: return None
-    def indexed_value(self, key, location):
-        if key in self.dict:
-            if len(self.dict[key]) > location:
-                return self.dict[key][location]
-            else: return None
-        else: return None
-    def value(self, key):
-        if key in self.dict: return self.dict[key][0]
-        else: return None
-    def length(self, key):
-        return len(self.dict[key])
-    def stripped(self, key):
-        if key in self.dict: return self.dict[key][0].strip()
-        else: return None
-    def pars(self):
-        return self.dict
-
-
 # Test/debug code
 # ===============
 
diff --git a/Lib/test/test_cgi.py b/Lib/test/test_cgi.py
index b1102cf..f28719b 100644
--- a/Lib/test/test_cgi.py
+++ b/Lib/test/test_cgi.py
@@ -143,56 +143,22 @@
             self.assertEqual(d, expect, "Error parsing %s" % repr(orig))
 
             env = {'QUERY_STRING': orig}
-            fcd = cgi.FormContentDict(env)
-            sd = cgi.SvFormContentDict(env)
             fs = cgi.FieldStorage(environ=env)
             if type(expect) == type({}):
                 # test dict interface
-                self.assertEqual(len(expect), len(fcd))
-                self.assertEqual(norm(expect.keys()), norm(fcd.keys()))
-                self.assertEqual(norm(expect.values()), norm(fcd.values()))
-                self.assertEqual(norm(expect.items()), norm(fcd.items()))
-                self.assertEqual(fcd.get("nonexistent field", "default"), "default")
-                self.assertEqual(len(sd), len(fs))
-                self.assertEqual(norm(sd.keys()), norm(fs.keys()))
+                self.assertEqual(len(expect), len(fs))
+                self.assertEqual(norm(expect.keys()), norm(fs.keys()))
+                ##self.assertEqual(norm(expect.values()), norm(fs.values()))
+                ##self.assertEqual(norm(expect.items()), norm(fs.items()))
                 self.assertEqual(fs.getvalue("nonexistent field", "default"), "default")
                 # test individual fields
                 for key in expect.keys():
                     expect_val = expect[key]
-                    self.assert_(key in fcd)
-                    self.assertEqual(norm(fcd[key]), norm(expect[key]))
-                    self.assertEqual(fcd.get(key, "default"), fcd[key])
                     self.assert_(key in fs)
                     if len(expect_val) > 1:
-                        single_value = 0
-                    else:
-                        single_value = 1
-                    try:
-                        val = sd[key]
-                    except IndexError:
-                        self.failIf(single_value)
                         self.assertEqual(fs.getvalue(key), expect_val)
                     else:
-                        self.assert_(single_value)
-                        self.assertEqual(val, expect_val[0])
                         self.assertEqual(fs.getvalue(key), expect_val[0])
-                    self.assertEqual(norm(sd.getlist(key)), norm(expect_val))
-                    if single_value:
-                        self.assertEqual(norm(sd.values()),
-                               first_elts(norm(expect.values())))
-                        self.assertEqual(norm(sd.items()),
-                               first_second_elts(norm(expect.items())))
-
-    def test_weird_formcontentdict(self):
-        # Test the weird FormContentDict classes
-        env = {'QUERY_STRING': "x=1&y=2.0&z=2-3.%2b0&1=1abc"}
-        expect = {'x': 1, 'y': 2.0, 'z': '2-3.+0', '1': '1abc'}
-        d = cgi.InterpFormContentDict(env)
-        for k, v in expect.items():
-            self.assertEqual(d[k], v)
-        for k, v in d.items():
-            self.assertEqual(expect[k], v)
-        self.assertEqual(norm(expect.values()), norm(d.values()))
 
     def test_log(self):
         cgi.log("Testing")