@@ -327,7 +327,7 @@ loops that truncate the stream.
    example :func:`islice` or :func:`takewhile`).
 
 
-.. function:: product(*iterables)
+.. function:: product(*iterables[, repeat])
 
    Cartesian product of input iterables.
 
@@ -340,11 +340,15 @@ loops that truncate the stream.
    so that if the inputs iterables are sorted, the product tuples are emitted
    in sorted order.
 
+   To compute the product of an iterable with itself, specify the number of
+   repetitions with the optional *repeat* keyword argument.  For example,
+   ``product(A, repeat=4)`` means the same as ``product(A, A, A, A)``.
+
    Equivalent to the following except that the actual implementation does not
    build-up intermediate results in memory::
 
-       def product(*args):
-           pools = map(tuple, args)
+       def product(*args, **kwds):
+           pools = map(tuple, args) * kwds.get('repeat', 1)
            if pools:            
                result = [[]]
                for pool in pools:
 
@@ -532,6 +532,9 @@ given type object has a specified feature.
 #define Py_TPFLAGS_HAVE_VERSION_TAG   (1L<<18)
 #define Py_TPFLAGS_VALID_VERSION_TAG  (1L<<19)
 
+/* Type is abstract and cannot be instantiated */
+#define Py_TPFLAGS_IS_ABSTRACT (1L<<20)
+
 /* These flags are used to determine if a type is a subclass. */
 #define Py_TPFLAGS_INT_SUBCLASS		(1L<<23)
 #define Py_TPFLAGS_LONG_SUBCLASS	(1L<<24)
 
@@ -52,50 +52,6 @@ def setx(self, value): ...
     __isabstractmethod__ = True
 
 
-class _Abstract(object):
-
-    """Helper class inserted into the bases by ABCMeta (using _fix_bases()).
-
-    You should never need to explicitly subclass this class.
-    """
-
-    def __new__(cls, *args, **kwds):
-        am = cls.__dict__.get("__abstractmethods__")
-        if am:
-            raise TypeError("Can't instantiate abstract class %s "
-                            "with abstract methods %s" %
-                            (cls.__name__, ", ".join(sorted(am))))
-        if (args or kwds) and cls.__init__ is object.__init__:
-            raise TypeError("Can't pass arguments to __new__ "
-                            "without overriding __init__")
-        return super().__new__(cls)
-
-    @classmethod
-    def __subclasshook__(cls, subclass):
-        """Abstract classes can override this to customize issubclass().
-
-        This is invoked early on by __subclasscheck__() below.  It
-        should return True, False or NotImplemented.  If it returns
-        NotImplemented, the normal algorithm is used.  Otherwise, it
-        overrides the normal algorithm (and the outcome is cached).
-        """
-        return NotImplemented
-
-
-def _fix_bases(bases):
-    """Helper method that inserts _Abstract in the bases if needed."""
-    for base in bases:
-        if issubclass(base, _Abstract):
-            # _Abstract is already a base (maybe indirectly)
-            return bases
-    if object in bases:
-        # Replace object with _Abstract
-        return tuple([_Abstract if base is object else base
-                      for base in bases])
-    # Append _Abstract to the end
-    return bases + (_Abstract,)
-
-
 class ABCMeta(type):
 
     """Metaclass for defining Abstract Base Classes (ABCs).
@@ -118,7 +74,6 @@ class ABCMeta(type):
     _abc_invalidation_counter = 0
 
     def __new__(mcls, name, bases, namespace):
-        bases = _fix_bases(bases)
         cls = super().__new__(mcls, name, bases, namespace)
         # Compute set of abstract method names
         abstracts = {name
@@ -129,7 +84,7 @@ def __new__(mcls, name, bases, namespace):
                 value = getattr(cls, name, None)
                 if getattr(value, "__isabstractmethod__", False):
                     abstracts.add(name)
-        cls.__abstractmethods__ = abstracts
+        cls.__abstractmethods__ = frozenset(abstracts)
         # Set up inheritance registry
         cls._abc_registry = WeakSet()
         cls._abc_cache = WeakSet()
 
@@ -1649,6 +1649,9 @@ def _round_down(self, prec):
         else:
             return -1
 
+    def __round__(self):
+        return self._round_down(0)
+
     def _round_up(self, prec):
         """Rounds away from 0."""
         return -self._round_down(prec)
@@ -1684,13 +1687,19 @@ def _round_ceiling(self, prec):
         else:
             return -self._round_down(prec)
 
+    def __ceil__(self):
+        return self._round_ceiling(0)
+
     def _round_floor(self, prec):
         """Rounds down (not towards 0 if negative)"""
         if not self._sign:
             return self._round_down(prec)
         else:
             return -self._round_down(prec)
 
+    def __floor__(self):
+        return self._round_floor(0)
+
     def _round_05up(self, prec):
         """Round down unless digit prec-1 is 0 or 5."""
         if prec and self._int[prec-1] not in '05':
 
@@ -196,6 +196,7 @@ def merge(self, other):
      '__setattr__',
      '__setitem__',
      '__str__',
+     '__subclasshook__',
      'append',
      'count',
      'extend',