Renamed PyString to PyBytes

35 files changed, 1094 insertions, 1094 deletions

diff --git a/Objects/abstract.c b/Objects/abstract.c
index 83de88f..3e6feb5 100644
--- a/Objects/abstract.c
+++ b/Objects/abstract.c
@@ -105,7 +105,7 @@ _PyObject_LengthHint(PyObject *o, Py_ssize_t defaultvalue)
 
 	/* cache a hashed version of the attribute string */
 	if (hintstrobj == NULL) {
-		hintstrobj = PyString_InternFromString("__length_hint__");
+		hintstrobj = PyBytes_InternFromString("__length_hint__");
 		if (hintstrobj == NULL)
 			goto defaultcase;
 	}
@@ -227,7 +227,7 @@ PyObject_DelItemString(PyObject *o, char *key)
 		null_error();
 		return -1;
 	}
-	okey = PyString_FromString(key);
+	okey = PyBytes_FromString(key);
 	if (okey == NULL)
 		return -1;
 	ret = PyObject_DelItem(o, okey);
@@ -729,21 +729,21 @@ PyObject_Format(PyObject* obj, PyObject *format_spec)
 	/* Initialize cached value */
 	if (str__format__ == NULL) {
 		/* Initialize static variable needed by _PyType_Lookup */
-		str__format__ = PyString_InternFromString("__format__");
+		str__format__ = PyBytes_InternFromString("__format__");
 		if (str__format__ == NULL)
 			goto done;
 	}
 
 	/* If no format_spec is provided, use an empty string */
 	if (format_spec == NULL) {
-		empty = PyString_FromStringAndSize(NULL, 0);
+		empty = PyBytes_FromStringAndSize(NULL, 0);
 		format_spec = empty;
 	}
 
 	/* Check the format_spec type, and make sure it's str or unicode */
 	if (PyUnicode_Check(format_spec))
 		spec_is_unicode = 1;
-	else if (PyString_Check(format_spec))
+	else if (PyBytes_Check(format_spec))
 		spec_is_unicode = 0;
 	else {
 		PyErr_Format(PyExc_TypeError,
@@ -823,7 +823,7 @@ PyObject_Format(PyObject* obj, PyObject *format_spec)
 	/* Check the result type, and make sure it's str or unicode */
 	if (PyUnicode_Check(result))
 		result_is_unicode = 1;
-	else if (PyString_Check(result))
+	else if (PyBytes_Check(result))
 		result_is_unicode = 0;
 	else {
 		PyErr_Format(PyExc_TypeError,
@@ -1541,7 +1541,7 @@ _PyNumber_ConvertIntegralToInt(PyObject *integral, const char* error_format)
 	const char *type_name;
 	static PyObject *int_name = NULL;
 	if (int_name == NULL) {
-		int_name = PyString_InternFromString("__int__");
+		int_name = PyBytes_InternFromString("__int__");
 		if (int_name == NULL)
 			return NULL;
 	}
@@ -1567,7 +1567,7 @@ _PyNumber_ConvertIntegralToInt(PyObject *integral, const char* error_format)
 
 non_integral_error:
 	if (PyInstance_Check(integral)) {
-		type_name = PyString_AS_STRING(((PyInstanceObject *)integral)
+		type_name = PyBytes_AS_STRING(((PyInstanceObject *)integral)
 					       ->in_class->cl_name);
 	}
 	else {
@@ -1589,7 +1589,7 @@ PyNumber_Int(PyObject *o)
 	Py_ssize_t buffer_len;
 
 	if (trunc_name == NULL) {
-		trunc_name = PyString_InternFromString("__trunc__");
+		trunc_name = PyBytes_InternFromString("__trunc__");
 		if (trunc_name == NULL)
 			return NULL;
 	}
@@ -1629,9 +1629,9 @@ PyNumber_Int(PyObject *o)
 	}
 	PyErr_Clear();  /* It's not an error if  o.__trunc__ doesn't exist. */
 
-	if (PyString_Check(o))
-		return int_from_string(PyString_AS_STRING(o),
-				       PyString_GET_SIZE(o));
+	if (PyBytes_Check(o))
+		return int_from_string(PyBytes_AS_STRING(o),
+				       PyBytes_GET_SIZE(o));
 #ifdef Py_USING_UNICODE
 	if (PyUnicode_Check(o))
 		return PyInt_FromUnicode(PyUnicode_AS_UNICODE(o),
@@ -1674,7 +1674,7 @@ PyNumber_Long(PyObject *o)
 	Py_ssize_t buffer_len;
 
 	if (trunc_name == NULL) {
-		trunc_name = PyString_InternFromString("__trunc__");
+		trunc_name = PyBytes_InternFromString("__trunc__");
 		if (trunc_name == NULL)
 			return NULL;
 	}
@@ -1716,13 +1716,13 @@ PyNumber_Long(PyObject *o)
 	}
 	PyErr_Clear();  /* It's not an error if  o.__trunc__ doesn't exist. */
 
-	if (PyString_Check(o))
+	if (PyBytes_Check(o))
 		/* need to do extra error checking that PyLong_FromString()
 		 * doesn't do.  In particular long('9.5') must raise an
 		 * exception, not truncate the float.
 		 */
-		return long_from_string(PyString_AS_STRING(o),
-					PyString_GET_SIZE(o));
+		return long_from_string(PyBytes_AS_STRING(o),
+					PyBytes_GET_SIZE(o));
 #ifdef Py_USING_UNICODE
 	if (PyUnicode_Check(o))
 		/* The above check is done in PyLong_FromUnicode(). */
@@ -2413,7 +2413,7 @@ PyMapping_GetItemString(PyObject *o, char *key)
 	if (key == NULL)
 		return null_error();
 
-	okey = PyString_FromString(key);
+	okey = PyBytes_FromString(key);
 	if (okey == NULL)
 		return NULL;
 	r = PyObject_GetItem(o, okey);
@@ -2432,7 +2432,7 @@ PyMapping_SetItemString(PyObject *o, char *key, PyObject *value)
 		return -1;
 	}
 
-	okey = PyString_FromString(key);
+	okey = PyBytes_FromString(key);
 	if (okey == NULL)
 		return -1;
 	r = PyObject_SetItem(o, okey, value);
@@ -2760,7 +2760,7 @@ abstract_get_bases(PyObject *cls)
 	PyObject *bases;
 
 	if (__bases__ == NULL) {
-		__bases__ = PyString_InternFromString("__bases__");
+		__bases__ = PyBytes_InternFromString("__bases__");
 		if (__bases__ == NULL)
 			return NULL;
 	}
@@ -2838,7 +2838,7 @@ recursive_isinstance(PyObject *inst, PyObject *cls, int recursion_depth)
 	int retval = 0;
 
 	if (__class__ == NULL) {
-		__class__ = PyString_InternFromString("__class__");
+		__class__ = PyBytes_InternFromString("__class__");
 		if (__class__ == NULL)
 			return -1;
 	}
@@ -2914,7 +2914,7 @@ PyObject_IsInstance(PyObject *inst, PyObject *cls)
 		return 1;
 
 	if (name == NULL) {
-		name = PyString_InternFromString("__instancecheck__");
+		name = PyBytes_InternFromString("__instancecheck__");
 		if (name == NULL)
 			return -1;
 	}
@@ -2998,7 +2998,7 @@ PyObject_IsSubclass(PyObject *derived, PyObject *cls)
 	PyErr_Fetch(&t, &v, &tb);
 	
 	if (name == NULL) {
-		name = PyString_InternFromString("__subclasscheck__");
+		name = PyBytes_InternFromString("__subclasscheck__");
 		if (name == NULL)
 			return -1;
 	}
diff --git a/Objects/boolobject.c b/Objects/boolobject.c
index fd73d28..93affd1 100644
--- a/Objects/boolobject.c
+++ b/Objects/boolobject.c
@@ -25,10 +25,10 @@ bool_repr(PyBoolObject *self)
 
 	if (self->ob_ival)
 		s = true_str ? true_str :
-			(true_str = PyString_InternFromString("True"));
+			(true_str = PyBytes_InternFromString("True"));
 	else
 		s = false_str ? false_str :
-			(false_str = PyString_InternFromString("False"));
+			(false_str = PyBytes_InternFromString("False"));
 	Py_XINCREF(s);
 	return s;
 }
diff --git a/Objects/bufferobject.c b/Objects/bufferobject.c
index 37d9bcb..ee8dd3d 100644
--- a/Objects/bufferobject.c
+++ b/Objects/bufferobject.c
@@ -287,13 +287,13 @@ buffer_repr(PyBufferObject *self)
 	const char *status = self->b_readonly ? "read-only" : "read-write";
 
 	if ( self->b_base == NULL )
-		return PyString_FromFormat("<%s buffer ptr %p, size %zd at %p>",
+		return PyBytes_FromFormat("<%s buffer ptr %p, size %zd at %p>",
 					   status,
 					   self->b_ptr,
 					   self->b_size,
 					   self);
 	else
-		return PyString_FromFormat(
+		return PyBytes_FromFormat(
 			"<%s buffer for %p, size %zd, offset %zd at %p>",
 			status,
 			self->b_base,
@@ -318,7 +318,7 @@ buffer_hash(PyBufferObject *self)
 	 * underlying memory is immutable.  b_readonly is a necessary but not
 	 * sufficient condition for a buffer to be hashable.  Perhaps it would
 	 * be better to only allow hashing if the underlying object is known to
-	 * be immutable (e.g. PyString_Check() is true).  Another idea would
+	 * be immutable (e.g. PyBytes_Check() is true).  Another idea would
 	 * be to call tp_hash on the underlying object and see if it raises
 	 * an error. */
 	if ( !self->b_readonly )
@@ -349,7 +349,7 @@ buffer_str(PyBufferObject *self)
 	Py_ssize_t size;
 	if (!get_buf(self, &ptr, &size, ANY_BUFFER))
 		return NULL;
-	return PyString_FromStringAndSize((const char *)ptr, size);
+	return PyBytes_FromStringAndSize((const char *)ptr, size);
 }
 
 /* Sequence methods */
@@ -401,10 +401,10 @@ buffer_concat(PyBufferObject *self, PyObject *other)
 	if ( (count = (*pb->bf_getreadbuffer)(other, 0, &ptr2)) < 0 )
 		return NULL;
 
- 	ob = PyString_FromStringAndSize(NULL, size + count);
+ 	ob = PyBytes_FromStringAndSize(NULL, size + count);
 	if ( ob == NULL )
 		return NULL;
- 	p = PyString_AS_STRING(ob);
+ 	p = PyBytes_AS_STRING(ob);
  	memcpy(p, ptr1, size);
  	memcpy(p + size, ptr2, count);
 
@@ -426,11 +426,11 @@ buffer_repeat(PyBufferObject *self, Py_ssize_t count)
 		count = 0;
 	if (!get_buf(self, &ptr, &size, ANY_BUFFER))
 		return NULL;
-	ob = PyString_FromStringAndSize(NULL, size * count);
+	ob = PyBytes_FromStringAndSize(NULL, size * count);
 	if ( ob == NULL )
 		return NULL;
 
-	p = PyString_AS_STRING(ob);
+	p = PyBytes_AS_STRING(ob);
 	while ( count-- )
 	{
 	    memcpy(p, ptr, size);
@@ -454,7 +454,7 @@ buffer_item(PyBufferObject *self, Py_ssize_t idx)
 		PyErr_SetString(PyExc_IndexError, "buffer index out of range");
 		return NULL;
 	}
-	return PyString_FromStringAndSize((char *)ptr + idx, 1);
+	return PyBytes_FromStringAndSize((char *)ptr + idx, 1);
 }
 
 static PyObject *
@@ -472,7 +472,7 @@ buffer_slice(PyBufferObject *self, Py_ssize_t left, Py_ssize_t right)
 		right = size;
 	if ( right < left )
 		right = left;
-	return PyString_FromStringAndSize((char *)ptr + left,
+	return PyBytes_FromStringAndSize((char *)ptr + left,
 					  right - left);
 }
 
@@ -501,9 +501,9 @@ buffer_subscript(PyBufferObject *self, PyObject *item)
 		}
 
 		if (slicelength <= 0)
-			return PyString_FromStringAndSize("", 0);
+			return PyBytes_FromStringAndSize("", 0);
 		else if (step == 1)
-			return PyString_FromStringAndSize((char *)p + start,
+			return PyBytes_FromStringAndSize((char *)p + start,
 							  stop - start);
 		else {
 			PyObject *result;
@@ -518,7 +518,7 @@ buffer_subscript(PyBufferObject *self, PyObject *item)
 				result_buf[i] = source_buf[cur];
 			}
 
-			result = PyString_FromStringAndSize(result_buf,
+			result = PyBytes_FromStringAndSize(result_buf,
 							    slicelength);
 			PyMem_Free(result_buf);
 			return result;
diff --git a/Objects/bytes_methods.c b/Objects/bytes_methods.c
index de87905..2d55601 100644
--- a/Objects/bytes_methods.c
+++ b/Objects/bytes_methods.c
@@ -462,11 +462,11 @@ _Py_bytes_lower(char *result, const char *cptr, Py_ssize_t len)
 	Py_ssize_t i;
 
         /*
-	newobj = PyString_FromStringAndSize(NULL, len);
+	newobj = PyBytes_FromStringAndSize(NULL, len);
 	if (!newobj)
 		return NULL;
 
-	s = PyString_AS_STRING(newobj);
+	s = PyBytes_AS_STRING(newobj);
         */
 
 	Py_MEMCPY(result, cptr, len);
@@ -490,11 +490,11 @@ _Py_bytes_upper(char *result, const char *cptr, Py_ssize_t len)
 	Py_ssize_t i;
 
         /*
-	newobj = PyString_FromStringAndSize(NULL, len);
+	newobj = PyBytes_FromStringAndSize(NULL, len);
 	if (!newobj)
 		return NULL;
 
-	s = PyString_AS_STRING(newobj);
+	s = PyBytes_AS_STRING(newobj);
         */
 
 	Py_MEMCPY(result, cptr, len);
@@ -520,10 +520,10 @@ _Py_bytes_title(char *result, char *s, Py_ssize_t len)
 	int previous_is_cased = 0;
 
         /*
-	newobj = PyString_FromStringAndSize(NULL, len);
+	newobj = PyBytes_FromStringAndSize(NULL, len);
 	if (newobj == NULL)
 		return NULL;
-	s_new = PyString_AsString(newobj);
+	s_new = PyBytes_AsString(newobj);
         */
 	for (i = 0; i < len; i++) {
 		int c = Py_CHARMASK(*s++);
@@ -553,10 +553,10 @@ _Py_bytes_capitalize(char *result, char *s, Py_ssize_t len)
 	Py_ssize_t i;
 
         /*
-	newobj = PyString_FromStringAndSize(NULL, len);
+	newobj = PyBytes_FromStringAndSize(NULL, len);
 	if (newobj == NULL)
 		return NULL;
-	s_new = PyString_AsString(newobj);
+	s_new = PyBytes_AsString(newobj);
         */
 	if (0 < len) {
 		int c = Py_CHARMASK(*s++);
@@ -589,10 +589,10 @@ _Py_bytes_swapcase(char *result, char *s, Py_ssize_t len)
 	Py_ssize_t i;
 
         /*
-	newobj = PyString_FromStringAndSize(NULL, len);
+	newobj = PyBytes_FromStringAndSize(NULL, len);
 	if (newobj == NULL)
 		return NULL;
-	s_new = PyString_AsString(newobj);
+	s_new = PyBytes_AsString(newobj);
         */
 	for (i = 0; i < len; i++) {
 		int c = Py_CHARMASK(*s++);
diff --git a/Objects/bytesobject.c b/Objects/bytesobject.c
index 25fec6d..6e5df19 100644
--- a/Objects/bytesobject.c
+++ b/Objects/bytesobject.c
@@ -41,12 +41,12 @@ _getbytevalue(PyObject* arg, int *value)
             return 0;
         }
     }
-    else if (PyString_CheckExact(arg)) {
+    else if (PyBytes_CheckExact(arg)) {
         if (Py_SIZE(arg) != 1) {
             PyErr_SetString(PyExc_ValueError, "string must be of size 1");
             return 0;
         }
-        face_value = Py_CHARMASK(((PyStringObject*)arg)->ob_sval[0]);
+        face_value = Py_CHARMASK(((PyBytesObject*)arg)->ob_sval[0]);
     }
     else {
         PyErr_Format(PyExc_TypeError, "an integer or string of size 1 is required");
@@ -768,13 +768,13 @@ bytes_init(PyByteArrayObject *self, PyObject *args, PyObject *kwds)
         return 0;
     }
 
-    if (PyString_Check(arg)) {
+    if (PyBytes_Check(arg)) {
         PyObject *new, *encoded;
         if (encoding != NULL) {
             encoded = PyCodec_Encode(arg, encoding, errors);
             if (encoded == NULL)
                 return -1;
-            assert(PyString_Check(encoded));
+            assert(PyBytes_Check(encoded));
         }
         else {
             encoded = arg;
@@ -799,7 +799,7 @@ bytes_init(PyByteArrayObject *self, PyObject *args, PyObject *kwds)
         encoded = PyCodec_Encode(arg, encoding, errors);
         if (encoded == NULL)
             return -1;
-        assert(PyString_Check(encoded));
+        assert(PyBytes_Check(encoded));
         new = bytes_iconcat(self, encoded);
         Py_DECREF(encoded);
         if (new == NULL)
@@ -1002,7 +1002,7 @@ bytes_str(PyObject *op)
     }
     return bytes_repr((PyByteArrayObject*)op);
 #endif
-    return PyString_FromStringAndSize(((PyByteArrayObject*)op)->ob_bytes, Py_SIZE(op));
+    return PyBytes_FromStringAndSize(((PyByteArrayObject*)op)->ob_bytes, Py_SIZE(op));
 }
 
 static PyObject *
@@ -2969,7 +2969,7 @@ bytes_join(PyByteArrayObject *self, PyObject *it)
     /* XXX Shouldn't we use _getbuffer() on these items instead? */
     for (i = 0; i < n; i++) {
         PyObject *obj = items[i];
-        if (!PyByteArray_Check(obj) && !PyString_Check(obj)) {
+        if (!PyByteArray_Check(obj) && !PyBytes_Check(obj)) {
             PyErr_Format(PyExc_TypeError,
                          "can only join an iterable of bytes "
                          "(item %ld has type '%.100s')",
@@ -2998,7 +2998,7 @@ bytes_join(PyByteArrayObject *self, PyObject *it)
         if (PyByteArray_Check(obj))
            buf = PyByteArray_AS_STRING(obj);
         else
-           buf = PyString_AS_STRING(obj);
+           buf = PyBytes_AS_STRING(obj);
         if (i) {
             memcpy(dest, self->ob_bytes, mysize);
             dest += mysize;
diff --git a/Objects/cellobject.c b/Objects/cellobject.c
index 4e0bcf8..16bb150 100644
--- a/Objects/cellobject.c
+++ b/Objects/cellobject.c
@@ -73,9 +73,9 @@ static PyObject *
 cell_repr(PyCellObject *op)
 {
 	if (op->ob_ref == NULL)
-		return PyString_FromFormat("<cell at %p: empty>", op);
+		return PyBytes_FromFormat("<cell at %p: empty>", op);
 
-	return PyString_FromFormat("<cell at %p: %.80s object at %p>",
+	return PyBytes_FromFormat("<cell at %p: %.80s object at %p>",
 				   op, op->ob_ref->ob_type->tp_name,
 				   op->ob_ref);
 }
diff --git a/Objects/classobject.c b/Objects/classobject.c
index caf6b3e..372a40e 100644
--- a/Objects/classobject.c
+++ b/Objects/classobject.c
@@ -32,21 +32,21 @@ PyClass_New(PyObject *bases, PyObject *dict, PyObject *name)
 	PyClassObject *op, *dummy;
 	static PyObject *docstr, *modstr, *namestr;
 	if (docstr == NULL) {
-		docstr= PyString_InternFromString("__doc__");
+		docstr= PyBytes_InternFromString("__doc__");
 		if (docstr == NULL)
 			return NULL;
 	}
 	if (modstr == NULL) {
-		modstr= PyString_InternFromString("__module__");
+		modstr= PyBytes_InternFromString("__module__");
 		if (modstr == NULL)
 			return NULL;
 	}
 	if (namestr == NULL) {
-		namestr= PyString_InternFromString("__name__");
+		namestr= PyBytes_InternFromString("__name__");
 		if (namestr == NULL)
 			return NULL;
 	}
-	if (name == NULL || !PyString_Check(name)) {
+	if (name == NULL || !PyBytes_Check(name)) {
 		PyErr_SetString(PyExc_TypeError,
 				"PyClass_New: name must be a string");
 		return NULL;
@@ -101,13 +101,13 @@ PyClass_New(PyObject *bases, PyObject *dict, PyObject *name)
 	}
 
 	if (getattrstr == NULL) {
-		getattrstr = PyString_InternFromString("__getattr__");
+		getattrstr = PyBytes_InternFromString("__getattr__");
 		if (getattrstr == NULL)
 			goto alloc_error;
-		setattrstr = PyString_InternFromString("__setattr__");
+		setattrstr = PyBytes_InternFromString("__setattr__");
 		if (setattrstr == NULL)
 			goto alloc_error;
-		delattrstr = PyString_InternFromString("__delattr__");
+		delattrstr = PyBytes_InternFromString("__delattr__");
 		if (delattrstr == NULL)
 			goto alloc_error;
 	}
@@ -222,7 +222,7 @@ static PyObject *
 class_getattr(register PyClassObject *op, PyObject *name)
 {
 	register PyObject *v;
-	register char *sname = PyString_AsString(name);
+	register char *sname = PyBytes_AsString(name);
 	PyClassObject *klass;
 	descrgetfunc f;
 
@@ -253,7 +253,7 @@ class_getattr(register PyClassObject *op, PyObject *name)
 	if (v == NULL) {
 		PyErr_Format(PyExc_AttributeError,
 			     "class %.50s has no attribute '%.400s'",
-			     PyString_AS_STRING(op->cl_name), sname);
+			     PyBytes_AS_STRING(op->cl_name), sname);
 		return NULL;
 	}
 	f = TP_DESCR_GET(v->ob_type);
@@ -316,9 +316,9 @@ set_bases(PyClassObject *c, PyObject *v)
 static char *
 set_name(PyClassObject *c, PyObject *v)
 {
-	if (v == NULL || !PyString_Check(v))
+	if (v == NULL || !PyBytes_Check(v))
 		return "__name__ must be a string object";
-	if (strlen(PyString_AS_STRING(v)) != (size_t)PyString_GET_SIZE(v))
+	if (strlen(PyBytes_AS_STRING(v)) != (size_t)PyBytes_GET_SIZE(v))
 		return "__name__ must not contain null bytes";
 	set_slot(&c->cl_name, v);
 	return "";
@@ -333,9 +333,9 @@ class_setattr(PyClassObject *op, PyObject *name, PyObject *v)
 			   "classes are read-only in restricted mode");
 		return -1;
 	}
-	sname = PyString_AsString(name);
+	sname = PyBytes_AsString(name);
 	if (sname[0] == '_' && sname[1] == '_') {
-		Py_ssize_t n = PyString_Size(name);
+		Py_ssize_t n = PyBytes_Size(name);
 		if (sname[n-1] == '_' && sname[n-2] == '_') {
 			char *err = NULL;
 			if (strcmp(sname, "__dict__") == 0)
@@ -365,7 +365,7 @@ class_setattr(PyClassObject *op, PyObject *name, PyObject *v)
 		if (rv < 0)
 			PyErr_Format(PyExc_AttributeError,
 				     "class %.50s has no attribute '%.400s'",
-				     PyString_AS_STRING(op->cl_name), sname);
+				     PyBytes_AS_STRING(op->cl_name), sname);
 		return rv;
 	}
 	else
@@ -377,15 +377,15 @@ class_repr(PyClassObject *op)
 {
 	PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");
 	char *name;
-	if (op->cl_name == NULL || !PyString_Check(op->cl_name))
+	if (op->cl_name == NULL || !PyBytes_Check(op->cl_name))
 		name = "?";
 	else
-		name = PyString_AsString(op->cl_name);
-	if (mod == NULL || !PyString_Check(mod))
-		return PyString_FromFormat("<class ?.%s at %p>", name, op);
+		name = PyBytes_AsString(op->cl_name);
+	if (mod == NULL || !PyBytes_Check(mod))
+		return PyBytes_FromFormat("<class ?.%s at %p>", name, op);
 	else
-		return PyString_FromFormat("<class %s.%s at %p>",
-					   PyString_AsString(mod),
+		return PyBytes_FromFormat("<class %s.%s at %p>",
+					   PyBytes_AsString(mod),
 					   name, op);
 }
 
@@ -397,21 +397,21 @@ class_str(PyClassObject *op)
 	PyObject *res;
 	Py_ssize_t m, n;
 
-	if (name == NULL || !PyString_Check(name))
+	if (name == NULL || !PyBytes_Check(name))
 		return class_repr(op);
-	if (mod == NULL || !PyString_Check(mod)) {
+	if (mod == NULL || !PyBytes_Check(mod)) {
 		Py_INCREF(name);
 		return name;
 	}
-	m = PyString_GET_SIZE(mod);
-	n = PyString_GET_SIZE(name);
-	res = PyString_FromStringAndSize((char *)NULL, m+1+n);
+	m = PyBytes_GET_SIZE(mod);
+	n = PyBytes_GET_SIZE(name);
+	res = PyBytes_FromStringAndSize((char *)NULL, m+1+n);
 	if (res != NULL) {
-		char *s = PyString_AS_STRING(res);
-		memcpy(s, PyString_AS_STRING(mod), m);
+		char *s = PyBytes_AS_STRING(res);
+		memcpy(s, PyBytes_AS_STRING(mod), m);
 		s += m;
 		*s++ = '.';
-		memcpy(s, PyString_AS_STRING(name), n);
+		memcpy(s, PyBytes_AS_STRING(name), n);
 	}
 	return res;
 }
@@ -541,7 +541,7 @@ PyInstance_New(PyObject *klass, PyObject *arg, PyObject *kw)
 	static PyObject *initstr;
 
 	if (initstr == NULL) {
-		initstr = PyString_InternFromString("__init__");
+		initstr = PyBytes_InternFromString("__init__");
 		if (initstr == NULL)
 			return NULL;
 	}
@@ -634,7 +634,7 @@ instance_dealloc(register PyInstanceObject *inst)
 	PyErr_Fetch(&error_type, &error_value, &error_traceback);
 	/* Execute __del__ method, if any. */
 	if (delstr == NULL) {
-		delstr = PyString_InternFromString("__del__");
+		delstr = PyBytes_InternFromString("__del__");
 		if (delstr == NULL)
 			PyErr_WriteUnraisable((PyObject*)inst);
 	}
@@ -696,7 +696,7 @@ static PyObject *
 instance_getattr1(register PyInstanceObject *inst, PyObject *name)
 {
 	register PyObject *v;
-	register char *sname = PyString_AsString(name);
+	register char *sname = PyBytes_AsString(name);
 	if (sname[0] == '_' && sname[1] == '_') {
 		if (strcmp(sname, "__dict__") == 0) {
 			if (PyEval_GetRestricted()) {
@@ -716,7 +716,7 @@ instance_getattr1(register PyInstanceObject *inst, PyObject *name)
 	if (v == NULL && !PyErr_Occurred()) {
 		PyErr_Format(PyExc_AttributeError,
 			     "%.50s instance has no attribute '%.400s'",
-			     PyString_AS_STRING(inst->in_class->cl_name), sname);
+			     PyBytes_AS_STRING(inst->in_class->cl_name), sname);
 	}
 	return v;
 }
@@ -779,7 +779,7 @@ _PyInstance_Lookup(PyObject *pinst, PyObject *name)
 	assert(PyInstance_Check(pinst));
 	inst = (PyInstanceObject *)pinst;
 
-	assert(PyString_Check(name));
+	assert(PyBytes_Check(name));
 
  	v = PyDict_GetItem(inst->in_dict, name);
 	if (v == NULL)
@@ -795,8 +795,8 @@ instance_setattr1(PyInstanceObject *inst, PyObject *name, PyObject *v)
 		if (rv < 0)
 			PyErr_Format(PyExc_AttributeError,
 				     "%.50s instance has no attribute '%.400s'",
-				     PyString_AS_STRING(inst->in_class->cl_name),
-				     PyString_AS_STRING(name));
+				     PyBytes_AS_STRING(inst->in_class->cl_name),
+				     PyBytes_AS_STRING(name));
 		return rv;
 	}
 	else
@@ -807,9 +807,9 @@ static int
 instance_setattr(PyInstanceObject *inst, PyObject *name, PyObject *v)
 {
 	PyObject *func, *args, *res, *tmp;
-	char *sname = PyString_AsString(name);
+	char *sname = PyBytes_AsString(name);
 	if (sname[0] == '_' && sname[1] == '_') {
-		Py_ssize_t n = PyString_Size(name);
+		Py_ssize_t n = PyBytes_Size(name);
 		if (sname[n-1] == '_' && sname[n-2] == '_') {
 			if (strcmp(sname, "__dict__") == 0) {
 				if (PyEval_GetRestricted()) {
@@ -875,7 +875,7 @@ instance_repr(PyInstanceObject *inst)
 	static PyObject *reprstr;
 
 	if (reprstr == NULL) {
-		reprstr = PyString_InternFromString("__repr__");
+		reprstr = PyBytes_InternFromString("__repr__");
 		if (reprstr == NULL)
 			return NULL;
 	}
@@ -889,16 +889,16 @@ instance_repr(PyInstanceObject *inst)
 		classname = inst->in_class->cl_name;
 		mod = PyDict_GetItemString(inst->in_class->cl_dict,
 					   "__module__");
-		if (classname != NULL && PyString_Check(classname))
-			cname = PyString_AsString(classname);
+		if (classname != NULL && PyBytes_Check(classname))
+			cname = PyBytes_AsString(classname);
 		else
 			cname = "?";
-		if (mod == NULL || !PyString_Check(mod))
-			return PyString_FromFormat("<?.%s instance at %p>",
+		if (mod == NULL || !PyBytes_Check(mod))
+			return PyBytes_FromFormat("<?.%s instance at %p>",
 						   cname, inst);
 		else
-			return PyString_FromFormat("<%s.%s instance at %p>",
-						   PyString_AsString(mod),
+			return PyBytes_FromFormat("<%s.%s instance at %p>",
+						   PyBytes_AsString(mod),
 						   cname, inst);
 	}
 	res = PyEval_CallObject(func, (PyObject *)NULL);
@@ -914,7 +914,7 @@ instance_str(PyInstanceObject *inst)
 	static PyObject *strstr;
 
 	if (strstr == NULL) {
-		strstr = PyString_InternFromString("__str__");
+		strstr = PyBytes_InternFromString("__str__");
 		if (strstr == NULL)
 			return NULL;
 	}
@@ -939,7 +939,7 @@ instance_hash(PyInstanceObject *inst)
 	static PyObject *hashstr, *eqstr, *cmpstr;
 
 	if (hashstr == NULL) {
-		hashstr = PyString_InternFromString("__hash__");
+		hashstr = PyBytes_InternFromString("__hash__");
 		if (hashstr == NULL)
 			return -1;
 	}
@@ -952,7 +952,7 @@ instance_hash(PyInstanceObject *inst)
 		   address.  If an __eq__ or __cmp__ method exists, there must
 		   be a __hash__. */
 		if (eqstr == NULL) {
-			eqstr = PyString_InternFromString("__eq__");
+			eqstr = PyBytes_InternFromString("__eq__");
 			if (eqstr == NULL)
 				return -1;
 		}
@@ -962,7 +962,7 @@ instance_hash(PyInstanceObject *inst)
 				return -1;
 			PyErr_Clear();
 			if (cmpstr == NULL) {
-				cmpstr = PyString_InternFromString("__cmp__");
+				cmpstr = PyBytes_InternFromString("__cmp__");
 				if (cmpstr == NULL)
 					return -1;
 			}
@@ -1014,7 +1014,7 @@ instance_length(PyInstanceObject *inst)
 	Py_ssize_t outcome;
 
 	if (lenstr == NULL) {
-		lenstr = PyString_InternFromString("__len__");
+		lenstr = PyBytes_InternFromString("__len__");
 		if (lenstr == NULL)
 			return -1;
 	}
@@ -1063,7 +1063,7 @@ instance_subscript(PyInstanceObject *inst, PyObject *key)
 	PyObject *res;
 
 	if (getitemstr == NULL) {
-		getitemstr = PyString_InternFromString("__getitem__");
+		getitemstr = PyBytes_InternFromString("__getitem__");
 		if (getitemstr == NULL)
 			return NULL;
 	}
@@ -1090,7 +1090,7 @@ instance_ass_subscript(PyInstanceObject *inst, PyObject *key, PyObject *value)
 
 	if (value == NULL) {
 		if (delitemstr == NULL) {
-			delitemstr = PyString_InternFromString("__delitem__");
+			delitemstr = PyBytes_InternFromString("__delitem__");
 			if (delitemstr == NULL)
 				return -1;
 		}
@@ -1098,7 +1098,7 @@ instance_ass_subscript(PyInstanceObject *inst, PyObject *key, PyObject *value)
 	}
 	else {
 		if (setitemstr == NULL) {
-			setitemstr = PyString_InternFromString("__setitem__");
+			setitemstr = PyBytes_InternFromString("__setitem__");
 			if (setitemstr == NULL)
 				return -1;
 		}
@@ -1135,7 +1135,7 @@ instance_item(PyInstanceObject *inst, Py_ssize_t i)
 	PyObject *func, *res;
 
 	if (getitemstr == NULL) {
-		getitemstr = PyString_InternFromString("__getitem__");
+		getitemstr = PyBytes_InternFromString("__getitem__");
 		if (getitemstr == NULL)
 			return NULL;
 	}
@@ -1154,7 +1154,7 @@ instance_slice(PyInstanceObject *inst, Py_ssize_t i, Py_ssize_t j)
 	static PyObject *getslicestr;
 
 	if (getslicestr == NULL) {
-		getslicestr = PyString_InternFromString("__getslice__");
+		getslicestr = PyBytes_InternFromString("__getslice__");
 		if (getslicestr == NULL)
 			return NULL;
 	}
@@ -1166,7 +1166,7 @@ instance_slice(PyInstanceObject *inst, Py_ssize_t i, Py_ssize_t j)
 		PyErr_Clear();
 
 		if (getitemstr == NULL) {
-			getitemstr = PyString_InternFromString("__getitem__");
+			getitemstr = PyBytes_InternFromString("__getitem__");
 			if (getitemstr == NULL)
 				return NULL;
 		}
@@ -1194,7 +1194,7 @@ instance_ass_item(PyInstanceObject *inst, Py_ssize_t i, PyObject *item)
 
 	if (item == NULL) {
 		if (delitemstr == NULL) {
-			delitemstr = PyString_InternFromString("__delitem__");
+			delitemstr = PyBytes_InternFromString("__delitem__");
 			if (delitemstr == NULL)
 				return -1;
 		}
@@ -1202,7 +1202,7 @@ instance_ass_item(PyInstanceObject *inst, Py_ssize_t i, PyObject *item)
 	}
 	else {
 		if (setitemstr == NULL) {
-			setitemstr = PyString_InternFromString("__setitem__");
+			setitemstr = PyBytes_InternFromString("__setitem__");
 			if (setitemstr == NULL)
 				return -1;
 		}
@@ -1236,7 +1236,7 @@ instance_ass_slice(PyInstanceObject *inst, Py_ssize_t i, Py_ssize_t j, PyObject
 	if (value == NULL) {
 		if (delslicestr == NULL) {
 			delslicestr =
-				PyString_InternFromString("__delslice__");
+				PyBytes_InternFromString("__delslice__");
 			if (delslicestr == NULL)
 				return -1;
 		}
@@ -1247,7 +1247,7 @@ instance_ass_slice(PyInstanceObject *inst, Py_ssize_t i, Py_ssize_t j, PyObject
 			PyErr_Clear();
 			if (delitemstr == NULL) {
 				delitemstr =
-				    PyString_InternFromString("__delitem__");
+				    PyBytes_InternFromString("__delitem__");
 				if (delitemstr == NULL)
 					return -1;
 			}
@@ -1263,7 +1263,7 @@ instance_ass_slice(PyInstanceObject *inst, Py_ssize_t i, Py_ssize_t j, PyObject
 	else {
 		if (setslicestr == NULL) {
 			setslicestr =
-				PyString_InternFromString("__setslice__");
+				PyBytes_InternFromString("__setslice__");
 			if (setslicestr == NULL)
 				return -1;
 		}
@@ -1274,7 +1274,7 @@ instance_ass_slice(PyInstanceObject *inst, Py_ssize_t i, Py_ssize_t j, PyObject
 			PyErr_Clear();
 			if (setitemstr == NULL) {
 				setitemstr =
-				    PyString_InternFromString("__setitem__");
+				    PyBytes_InternFromString("__setitem__");
 				if (setitemstr == NULL)
 					return -1;
 			}
@@ -1311,7 +1311,7 @@ instance_contains(PyInstanceObject *inst, PyObject *member)
 	 */
 
 	if(__contains__ == NULL) {
-		__contains__ = PyString_InternFromString("__contains__");
+		__contains__ = PyBytes_InternFromString("__contains__");
 		if(__contains__ == NULL)
 			return -1;
 	}
@@ -1417,7 +1417,7 @@ half_binop(PyObject *v, PyObject *w, char *opname, binaryfunc thisfunc,
 	}
 
 	if (coerce_obj == NULL) {
-		coerce_obj = PyString_InternFromString("__coerce__");
+		coerce_obj = PyBytes_InternFromString("__coerce__");
 		if (coerce_obj == NULL)
 			return NULL;
 	}
@@ -1504,7 +1504,7 @@ instance_coerce(PyObject **pv, PyObject **pw)
 	PyObject *coerced;
 
 	if (coerce_obj == NULL) {
-		coerce_obj = PyString_InternFromString("__coerce__");
+		coerce_obj = PyBytes_InternFromString("__coerce__");
 		if (coerce_obj == NULL)
 			return -1;
 	}
@@ -1552,7 +1552,7 @@ instance_coerce(PyObject **pv, PyObject **pw)
 #define UNARY(funcname, methodname) \
 static PyObject *funcname(PyInstanceObject *self) { \
 	static PyObject *o; \
-	if (o == NULL) { o = PyString_InternFromString(methodname); \
+	if (o == NULL) { o = PyBytes_InternFromString(methodname); \
 			 if (o == NULL) return NULL; } \
 	return generic_unary_op(self, o); \
 }
@@ -1561,7 +1561,7 @@ static PyObject *funcname(PyInstanceObject *self) { \
 #define UNARY_FB(funcname, methodname, funcname_fb) \
 static PyObject *funcname(PyInstanceObject *self) { \
 	static PyObject *o; \
-	if (o == NULL) { o = PyString_InternFromString(methodname); \
+	if (o == NULL) { o = PyBytes_InternFromString(methodname); \
 			 if (o == NULL) return NULL; } \
 	if (PyObject_HasAttr((PyObject*)self, o)) \
 		return generic_unary_op(self, o); \
@@ -1630,7 +1630,7 @@ half_cmp(PyObject *v, PyObject *w)
 	assert(PyInstance_Check(v));
 
 	if (cmp_obj == NULL) {
-		cmp_obj = PyString_InternFromString("__cmp__");
+		cmp_obj = PyBytes_InternFromString("__cmp__");
 		if (cmp_obj == NULL)
 			return -2;
 	}
@@ -1738,7 +1738,7 @@ instance_nonzero(PyInstanceObject *self)
 	static PyObject *nonzerostr;
 
 	if (nonzerostr == NULL) {
-		nonzerostr = PyString_InternFromString("__nonzero__");
+		nonzerostr = PyBytes_InternFromString("__nonzero__");
 		if (nonzerostr == NULL)
 			return -1;
 	}
@@ -1747,7 +1747,7 @@ instance_nonzero(PyInstanceObject *self)
 			return -1;
 		PyErr_Clear();
 		if (lenstr == NULL) {
-			lenstr = PyString_InternFromString("__len__");
+			lenstr = PyBytes_InternFromString("__len__");
 			if (lenstr == NULL)
 				return -1;
 		}
@@ -1787,7 +1787,7 @@ instance_index(PyInstanceObject *self)
 	static PyObject *indexstr = NULL;
 
 	if (indexstr == NULL) {
-		indexstr = PyString_InternFromString("__index__");
+		indexstr = PyBytes_InternFromString("__index__");
 		if (indexstr == NULL)
 			return NULL;
 	}	
@@ -1814,7 +1814,7 @@ instance_int(PyInstanceObject *self)
 	PyObject *truncated;
 	static PyObject *int_name;
 	if (int_name == NULL) {
-		int_name = PyString_InternFromString("__int__");
+		int_name = PyBytes_InternFromString("__int__");
 		if (int_name == NULL)
 			return NULL;
 	}
@@ -1929,7 +1929,7 @@ init_name_op(void)
 	if (name_op == NULL)
 		return -1;
 	for (i = 0; i < NAME_OPS; ++i) {
-		name_op[i] = PyString_InternFromString(_name_op[i]);
+		name_op[i] = PyBytes_InternFromString(_name_op[i]);
 		if (name_op[i] == NULL)
 			return -1;
 	}
@@ -2012,12 +2012,12 @@ instance_getiter(PyInstanceObject *self)
 	PyObject *func;
 
 	if (iterstr == NULL) {
-		iterstr = PyString_InternFromString("__iter__");
+		iterstr = PyBytes_InternFromString("__iter__");
 		if (iterstr == NULL)
 			return NULL;
 	}
 	if (getitemstr == NULL) {
-		getitemstr = PyString_InternFromString("__getitem__");
+		getitemstr = PyBytes_InternFromString("__getitem__");
 		if (getitemstr == NULL)
 			return NULL;
 	}
@@ -2055,7 +2055,7 @@ instance_iternext(PyInstanceObject *self)
 	PyObject *func;
 
 	if (nextstr == NULL) {
-		nextstr = PyString_InternFromString("next");
+		nextstr = PyBytes_InternFromString("next");
 		if (nextstr == NULL)
 			return NULL;
 	}
@@ -2087,7 +2087,7 @@ instance_call(PyObject *func, PyObject *arg, PyObject *kw)
 		PyErr_Clear();
 		PyErr_Format(PyExc_AttributeError,
 			     "%.200s instance has no __call__ method",
-			     PyString_AsString(inst->in_class->cl_name));
+			     PyBytes_AsString(inst->in_class->cl_name));
 		return NULL;
 	}
 	/* We must check and increment the recursion depth here. Scenario:
@@ -2261,7 +2261,7 @@ instancemethod_get_doc(PyMethodObject *im, void *context)
 {
 	static PyObject *docstr;
 	if (docstr == NULL) {
-		docstr= PyString_InternFromString("__doc__");
+		docstr= PyBytes_InternFromString("__doc__");
 		if (docstr == NULL)
 			return NULL;
 	}
@@ -2384,12 +2384,12 @@ instancemethod_repr(PyMethodObject *a)
 			return NULL;
 		PyErr_Clear();
 	}
-	else if (!PyString_Check(funcname)) {
+	else if (!PyBytes_Check(funcname)) {
 		Py_DECREF(funcname);
 		funcname = NULL;
 	}
 	else
-		sfuncname = PyString_AS_STRING(funcname);
+		sfuncname = PyBytes_AS_STRING(funcname);
 	if (klass == NULL)
 		klassname = NULL;
 	else {
@@ -2399,28 +2399,28 @@ instancemethod_repr(PyMethodObject *a)
 				return NULL;
 			PyErr_Clear();
 		}
-		else if (!PyString_Check(klassname)) {
+		else if (!PyBytes_Check(klassname)) {
 			Py_DECREF(klassname);
 			klassname = NULL;
 		}
 		else
-			sklassname = PyString_AS_STRING(klassname);
+			sklassname = PyBytes_AS_STRING(klassname);
 	}
 	if (self == NULL)
-		result = PyString_FromFormat("<unbound method %s.%s>",
+		result = PyBytes_FromFormat("<unbound method %s.%s>",
 					     sklassname, sfuncname);
 	else {
 		/* XXX Shouldn't use repr() here! */
 		PyObject *selfrepr = PyObject_Repr(self);
 		if (selfrepr == NULL)
 			goto fail;
-		if (!PyString_Check(selfrepr)) {
+		if (!PyBytes_Check(selfrepr)) {
 			Py_DECREF(selfrepr);
 			goto fail;
 		}
-		result = PyString_FromFormat("<bound method %s.%s of %s>",
+		result = PyBytes_FromFormat("<bound method %s.%s of %s>",
 					     sklassname, sfuncname,
-					     PyString_AS_STRING(selfrepr));
+					     PyBytes_AS_STRING(selfrepr));
 		Py_DECREF(selfrepr);
 	}
   fail:
@@ -2472,8 +2472,8 @@ getclassname(PyObject *klass, char *buf, int bufsize)
 		PyErr_Clear();
 		return;
 	}
-	if (PyString_Check(name)) {
-		strncpy(buf, PyString_AS_STRING(name), bufsize);
+	if (PyBytes_Check(name)) {
+		strncpy(buf, PyBytes_AS_STRING(name), bufsize);
 		buf[bufsize-1] = '\0';
 	}
 	Py_DECREF(name);
diff --git a/Objects/codeobject.c b/Objects/codeobject.c
index e94b4cc..9892d9c 100644
--- a/Objects/codeobject.c
+++ b/Objects/codeobject.c
@@ -32,10 +32,10 @@ intern_strings(PyObject *tuple)
 
 	for (i = PyTuple_GET_SIZE(tuple); --i >= 0; ) {
 		PyObject *v = PyTuple_GET_ITEM(tuple, i);
-		if (v == NULL || !PyString_CheckExact(v)) {
+		if (v == NULL || !PyBytes_CheckExact(v)) {
 			Py_FatalError("non-string found in code slot");
 		}
-		PyString_InternInPlace(&PyTuple_GET_ITEM(tuple, i));
+		PyBytes_InternInPlace(&PyTuple_GET_ITEM(tuple, i));
 	}
 }
 
@@ -57,9 +57,9 @@ PyCode_New(int argcount, int nlocals, int stacksize, int flags,
 	    varnames == NULL || !PyTuple_Check(varnames) ||
 	    freevars == NULL || !PyTuple_Check(freevars) ||
 	    cellvars == NULL || !PyTuple_Check(cellvars) ||
-	    name == NULL || !PyString_Check(name) ||
-	    filename == NULL || !PyString_Check(filename) ||
-	    lnotab == NULL || !PyString_Check(lnotab) ||
+	    name == NULL || !PyBytes_Check(name) ||
+	    filename == NULL || !PyBytes_Check(filename) ||
+	    lnotab == NULL || !PyBytes_Check(lnotab) ||
 	    !PyObject_CheckReadBuffer(code)) {
 		PyErr_BadInternalCall();
 		return NULL;
@@ -71,11 +71,11 @@ PyCode_New(int argcount, int nlocals, int stacksize, int flags,
 	/* Intern selected string constants */
 	for (i = PyTuple_Size(consts); --i >= 0; ) {
 		PyObject *v = PyTuple_GetItem(consts, i);
-		if (!PyString_Check(v))
+		if (!PyBytes_Check(v))
 			continue;
-		if (!all_name_chars((unsigned char *)PyString_AS_STRING(v)))
+		if (!all_name_chars((unsigned char *)PyBytes_AS_STRING(v)))
 			continue;
-		PyString_InternInPlace(&PyTuple_GET_ITEM(consts, i));
+		PyBytes_InternInPlace(&PyTuple_GET_ITEM(consts, i));
 	}
 	co = PyObject_NEW(PyCodeObject, &PyCode_Type);
 	if (co != NULL) {
@@ -145,10 +145,10 @@ validate_and_copy_tuple(PyObject *tup)
 
 	for (i = 0; i < len; i++) {
 		item = PyTuple_GET_ITEM(tup, i);
-		if (PyString_CheckExact(item)) {
+		if (PyBytes_CheckExact(item)) {
 			Py_INCREF(item);
 		}
-		else if (!PyString_Check(item)) {
+		else if (!PyBytes_Check(item)) {
 			PyErr_Format(
 				PyExc_TypeError,
 				"name tuples must contain only "
@@ -158,9 +158,9 @@ validate_and_copy_tuple(PyObject *tup)
 			return NULL;
 		}
 		else {
-			item = PyString_FromStringAndSize(
-				PyString_AS_STRING(item),
-				PyString_GET_SIZE(item));
+			item = PyBytes_FromStringAndSize(
+				PyBytes_AS_STRING(item),
+				PyBytes_GET_SIZE(item));
 			if (item == NULL) {
 				Py_DECREF(newtuple);
 				return NULL;
@@ -281,14 +281,14 @@ code_repr(PyCodeObject *co)
 
 	if (co->co_firstlineno != 0)
 		lineno = co->co_firstlineno;
-	if (co->co_filename && PyString_Check(co->co_filename))
-		filename = PyString_AS_STRING(co->co_filename);
-	if (co->co_name && PyString_Check(co->co_name))
-		name = PyString_AS_STRING(co->co_name);
+	if (co->co_filename && PyBytes_Check(co->co_filename))
+		filename = PyBytes_AS_STRING(co->co_filename);
+	if (co->co_name && PyBytes_Check(co->co_name))
+		name = PyBytes_AS_STRING(co->co_name);
 	PyOS_snprintf(buf, sizeof(buf),
 		      "<code object %.100s at %p, file \"%.300s\", line %d>",
 		      name, co, filename, lineno);
-	return PyString_FromString(buf);
+	return PyBytes_FromString(buf);
 }
 
 static int
@@ -508,8 +508,8 @@ was actually done until 2.2) expand 300, 300 to 255, 255,  45, 45, but to
 int
 PyCode_Addr2Line(PyCodeObject *co, int addrq)
 {
-	int size = PyString_Size(co->co_lnotab) / 2;
-	unsigned char *p = (unsigned char*)PyString_AsString(co->co_lnotab);
+	int size = PyBytes_Size(co->co_lnotab) / 2;
+	unsigned char *p = (unsigned char*)PyBytes_AsString(co->co_lnotab);
 	int line = co->co_firstlineno;
 	int addr = 0;
 	while (--size >= 0) {
@@ -604,8 +604,8 @@ PyCode_CheckLineNumber(PyCodeObject* co, int lasti, PyAddrPair *bounds)
         int size, addr, line;
         unsigned char* p;
 
-        p = (unsigned char*)PyString_AS_STRING(co->co_lnotab);
-        size = PyString_GET_SIZE(co->co_lnotab) / 2;
+        p = (unsigned char*)PyBytes_AS_STRING(co->co_lnotab);
+        size = PyBytes_GET_SIZE(co->co_lnotab) / 2;
 
         addr = 0;
         line = co->co_firstlineno;
diff --git a/Objects/complexobject.c b/Objects/complexobject.c
index 6e0fbb2..e22c200 100644
--- a/Objects/complexobject.c
+++ b/Objects/complexobject.c
@@ -303,7 +303,7 @@ PyComplex_AsCComplex(PyObject *op)
 	cv.imag = 0.;
 
 	if (complex_str == NULL) {
-		if (!(complex_str = PyString_InternFromString("__complex__")))
+		if (!(complex_str = PyBytes_InternFromString("__complex__")))
 			return cv;
 	}
 	
@@ -421,7 +421,7 @@ complex_repr(PyComplexObject *v)
 {
 	char buf[100];
 	complex_to_buf(buf, sizeof(buf), v, PREC_REPR);
-	return PyString_FromString(buf);
+	return PyBytes_FromString(buf);
 }
 
 static PyObject *
@@ -429,7 +429,7 @@ complex_str(PyComplexObject *v)
 {
 	char buf[100];
 	complex_to_buf(buf, sizeof(buf), v, PREC_STR);
-	return PyString_FromString(buf);
+	return PyBytes_FromString(buf);
 }
 
 static long
@@ -876,9 +876,9 @@ complex_subtype_from_string(PyTypeObject *type, PyObject *v)
 #endif
 	Py_ssize_t len;
 
-	if (PyString_Check(v)) {
-		s = PyString_AS_STRING(v);
-		len = PyString_GET_SIZE(v);
+	if (PyBytes_Check(v)) {
+		s = PyBytes_AS_STRING(v);
+		len = PyBytes_GET_SIZE(v);
 	}
 #ifdef Py_USING_UNICODE
 	else if (PyUnicode_Check(v)) {
@@ -1064,7 +1064,7 @@ complex_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 		Py_INCREF(r);
 		return r;
 	}
-	if (PyString_Check(r) || PyUnicode_Check(r)) {
+	if (PyBytes_Check(r) || PyUnicode_Check(r)) {
 		if (i != NULL) {
 			PyErr_SetString(PyExc_TypeError,
 					"complex() can't take second arg"
@@ -1073,7 +1073,7 @@ complex_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 		}
 		return complex_subtype_from_string(type, r);
 	}
-	if (i != NULL && (PyString_Check(i) || PyUnicode_Check(i))) {
+	if (i != NULL && (PyBytes_Check(i) || PyUnicode_Check(i))) {
 		PyErr_SetString(PyExc_TypeError,
 				"complex() second arg can't be a string");
 		return NULL;
@@ -1081,7 +1081,7 @@ complex_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 
 	/* XXX Hack to support classes with __complex__ method */
 	if (complexstr == NULL) {
-		complexstr = PyString_InternFromString("__complex__");
+		complexstr = PyBytes_InternFromString("__complex__");
 		if (complexstr == NULL)
 			return NULL;
 	}
diff --git a/Objects/descrobject.c b/Objects/descrobject.c
index fcc174e..7cf5e62 100644
--- a/Objects/descrobject.c
+++ b/Objects/descrobject.c
@@ -15,8 +15,8 @@ descr_dealloc(PyDescrObject *descr)
 static char *
 descr_name(PyDescrObject *descr)
 {
-	if (descr->d_name != NULL && PyString_Check(descr->d_name))
-		return PyString_AS_STRING(descr->d_name);
+	if (descr->d_name != NULL && PyBytes_Check(descr->d_name))
+		return PyBytes_AS_STRING(descr->d_name);
 	else
 		return "?";
 }
@@ -24,7 +24,7 @@ descr_name(PyDescrObject *descr)
 static PyObject *
 descr_repr(PyDescrObject *descr, char *format)
 {
-	return PyString_FromFormat(format, descr_name(descr),
+	return PyBytes_FromFormat(format, descr_name(descr),
 				   descr->d_type->tp_name);
 }
 
@@ -314,7 +314,7 @@ method_get_doc(PyMethodDescrObject *descr, void *closure)
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
-	return PyString_FromString(descr->d_method->ml_doc);
+	return PyBytes_FromString(descr->d_method->ml_doc);
 }
 
 static PyMemberDef descr_members[] = {
@@ -335,7 +335,7 @@ member_get_doc(PyMemberDescrObject *descr, void *closure)
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
-	return PyString_FromString(descr->d_member->doc);
+	return PyBytes_FromString(descr->d_member->doc);
 }
 
 static PyGetSetDef member_getset[] = {
@@ -350,7 +350,7 @@ getset_get_doc(PyGetSetDescrObject *descr, void *closure)
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
-	return PyString_FromString(descr->d_getset->doc);
+	return PyBytes_FromString(descr->d_getset->doc);
 }
 
 static PyGetSetDef getset_getset[] = {
@@ -365,7 +365,7 @@ wrapperdescr_get_doc(PyWrapperDescrObject *descr, void *closure)
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
-	return PyString_FromString(descr->d_base->doc);
+	return PyBytes_FromString(descr->d_base->doc);
 }
 
 static PyGetSetDef wrapperdescr_getset[] = {
@@ -576,7 +576,7 @@ descr_new(PyTypeObject *descrtype, PyTypeObject *type, const char *name)
 	if (descr != NULL) {
 		Py_XINCREF(type);
 		descr->d_type = type;
-		descr->d_name = PyString_InternFromString(name);
+		descr->d_name = PyBytes_InternFromString(name);
 		if (descr->d_name == NULL) {
 			Py_DECREF(descr);
 			descr = NULL;
@@ -922,7 +922,7 @@ wrapper_hash(wrapperobject *wp)
 static PyObject *
 wrapper_repr(wrapperobject *wp)
 {
-	return PyString_FromFormat("<method-wrapper '%s' of %s object at %p>",
+	return PyBytes_FromFormat("<method-wrapper '%s' of %s object at %p>",
 				   wp->descr->d_base->name,
 				   wp->self->ob_type->tp_name,
 				   wp->self);
@@ -947,7 +947,7 @@ wrapper_name(wrapperobject *wp)
 {
 	char *s = wp->descr->d_base->name;
 
-	return PyString_FromString(s);
+	return PyBytes_FromString(s);
 }
 
 static PyObject *
@@ -960,7 +960,7 @@ wrapper_doc(wrapperobject *wp)
 		return Py_None;
 	}
 	else {
-		return PyString_FromString(s);
+		return PyBytes_FromString(s);
 	}
 }
 
diff --git a/Objects/dictobject.c b/Objects/dictobject.c
index 102ea98..cdf0dfa 100644
--- a/Objects/dictobject.c
+++ b/Objects/dictobject.c
@@ -224,7 +224,7 @@ PyDict_New(void)
 {
 	register PyDictObject *mp;
 	if (dummy == NULL) { /* Auto-initialize dummy */
-		dummy = PyString_FromString("<dummy key>");
+		dummy = PyBytes_FromString("<dummy key>");
 		if (dummy == NULL)
 			return NULL;
 #ifdef SHOW_CONVERSION_COUNTS
@@ -373,7 +373,7 @@ lookdict(PyDictObject *mp, PyObject *key, register long hash)
  * this assumption allows testing for errors during PyObject_RichCompareBool()
  * to be dropped; string-string comparisons never raise exceptions.  This also
  * means we don't need to go through PyObject_RichCompareBool(); we can always
- * use _PyString_Eq() directly.
+ * use _PyBytes_Eq() directly.
  *
  * This is valuable because dicts with only string keys are very common.
  */
@@ -391,7 +391,7 @@ lookdict_string(PyDictObject *mp, PyObject *key, register long hash)
 	   including subclasses of str; e.g., one reason to subclass
 	   strings is to override __eq__, and for speed we don't cater to
 	   that here. */
-	if (!PyString_CheckExact(key)) {
+	if (!PyBytes_CheckExact(key)) {
 #ifdef SHOW_CONVERSION_COUNTS
 		++converted;
 #endif
@@ -405,7 +405,7 @@ lookdict_string(PyDictObject *mp, PyObject *key, register long hash)
 	if (ep->me_key == dummy)
 		freeslot = ep;
 	else {
-		if (ep->me_hash == hash && _PyString_Eq(ep->me_key, key))
+		if (ep->me_hash == hash && _PyBytes_Eq(ep->me_key, key))
 			return ep;
 		freeslot = NULL;
 	}
@@ -420,7 +420,7 @@ lookdict_string(PyDictObject *mp, PyObject *key, register long hash)
 		if (ep->me_key == key
 		    || (ep->me_hash == hash
 		        && ep->me_key != dummy
-			&& _PyString_Eq(ep->me_key, key)))
+			&& _PyBytes_Eq(ep->me_key, key)))
 			return ep;
 		if (ep->me_key == dummy && freeslot == NULL)
 			freeslot = ep;
@@ -626,8 +626,8 @@ PyDict_GetItem(PyObject *op, PyObject *key)
 	PyThreadState *tstate;
 	if (!PyDict_Check(op))
 		return NULL;
-	if (!PyString_CheckExact(key) ||
-	    (hash = ((PyStringObject *) key)->ob_shash) == -1)
+	if (!PyBytes_CheckExact(key) ||
+	    (hash = ((PyBytesObject *) key)->ob_shash) == -1)
 	{
 		hash = PyObject_Hash(key);
 		if (hash == -1) {
@@ -680,8 +680,8 @@ PyDict_SetItem(register PyObject *op, PyObject *key, PyObject *value)
 	assert(key);
 	assert(value);
 	mp = (PyDictObject *)op;
-	if (PyString_CheckExact(key)) {
-		hash = ((PyStringObject *)key)->ob_shash;
+	if (PyBytes_CheckExact(key)) {
+		hash = ((PyBytesObject *)key)->ob_shash;
 		if (hash == -1)
 			hash = PyObject_Hash(key);
 	}
@@ -728,8 +728,8 @@ PyDict_DelItem(PyObject *op, PyObject *key)
 		return -1;
 	}
 	assert(key);
-	if (!PyString_CheckExact(key) ||
-	    (hash = ((PyStringObject *) key)->ob_shash) == -1) {
+	if (!PyBytes_CheckExact(key) ||
+	    (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
 		hash = PyObject_Hash(key);
 		if (hash == -1)
 			return -1;
@@ -982,11 +982,11 @@ dict_repr(PyDictObject *mp)
 
 	i = Py_ReprEnter((PyObject *)mp);
 	if (i != 0) {
-		return i > 0 ? PyString_FromString("{...}") : NULL;
+		return i > 0 ? PyBytes_FromString("{...}") : NULL;
 	}
 
 	if (mp->ma_used == 0) {
-		result = PyString_FromString("{}");
+		result = PyBytes_FromString("{}");
 		goto Done;
 	}
 
@@ -994,7 +994,7 @@ dict_repr(PyDictObject *mp)
 	if (pieces == NULL)
 		goto Done;
 
-	colon = PyString_FromString(": ");
+	colon = PyBytes_FromString(": ");
 	if (colon == NULL)
 		goto Done;
 
@@ -1006,8 +1006,8 @@ dict_repr(PyDictObject *mp)
 		/* Prevent repr from deleting value during key format. */
 		Py_INCREF(value);
 		s = PyObject_Repr(key);
-		PyString_Concat(&s, colon);
-		PyString_ConcatAndDel(&s, PyObject_Repr(value));
+		PyBytes_Concat(&s, colon);
+		PyBytes_ConcatAndDel(&s, PyObject_Repr(value));
 		Py_DECREF(value);
 		if (s == NULL)
 			goto Done;
@@ -1019,29 +1019,29 @@ dict_repr(PyDictObject *mp)
 
 	/* Add "{}" decorations to the first and last items. */
 	assert(PyList_GET_SIZE(pieces) > 0);
-	s = PyString_FromString("{");
+	s = PyBytes_FromString("{");
 	if (s == NULL)
 		goto Done;
 	temp = PyList_GET_ITEM(pieces, 0);
-	PyString_ConcatAndDel(&s, temp);
+	PyBytes_ConcatAndDel(&s, temp);
 	PyList_SET_ITEM(pieces, 0, s);
 	if (s == NULL)
 		goto Done;
 
-	s = PyString_FromString("}");
+	s = PyBytes_FromString("}");
 	if (s == NULL)
 		goto Done;
 	temp = PyList_GET_ITEM(pieces, PyList_GET_SIZE(pieces) - 1);
-	PyString_ConcatAndDel(&temp, s);
+	PyBytes_ConcatAndDel(&temp, s);
 	PyList_SET_ITEM(pieces, PyList_GET_SIZE(pieces) - 1, temp);
 	if (temp == NULL)
 		goto Done;
 
 	/* Paste them all together with ", " between. */
-	s = PyString_FromString(", ");
+	s = PyBytes_FromString(", ");
 	if (s == NULL)
 		goto Done;
-	result = _PyString_Join(s, pieces);
+	result = _PyBytes_Join(s, pieces);
 	Py_DECREF(s);
 
 Done:
@@ -1064,8 +1064,8 @@ dict_subscript(PyDictObject *mp, register PyObject *key)
 	long hash;
 	PyDictEntry *ep;
 	assert(mp->ma_table != NULL);
-	if (!PyString_CheckExact(key) ||
-	    (hash = ((PyStringObject *) key)->ob_shash) == -1) {
+	if (!PyBytes_CheckExact(key) ||
+	    (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
 		hash = PyObject_Hash(key);
 		if (hash == -1)
 			return NULL;
@@ -1081,7 +1081,7 @@ dict_subscript(PyDictObject *mp, register PyObject *key)
 			static PyObject *missing_str = NULL;
 			if (missing_str == NULL)
 				missing_str =
-				  PyString_InternFromString("__missing__");
+				  PyBytes_InternFromString("__missing__");
 			missing = _PyType_Lookup(Py_TYPE(mp), missing_str);
 			if (missing != NULL)
 				return PyObject_CallFunctionObjArgs(missing,
@@ -1794,8 +1794,8 @@ dict_contains(register PyDictObject *mp, PyObject *key)
 	long hash;
 	PyDictEntry *ep;
 
-	if (!PyString_CheckExact(key) ||
-	    (hash = ((PyStringObject *) key)->ob_shash) == -1) {
+	if (!PyBytes_CheckExact(key) ||
+	    (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
 		hash = PyObject_Hash(key);
 		if (hash == -1)
 			return NULL;
@@ -1827,8 +1827,8 @@ dict_get(register PyDictObject *mp, PyObject *args)
 	if (!PyArg_UnpackTuple(args, "get", 1, 2, &key, &failobj))
 		return NULL;
 
-	if (!PyString_CheckExact(key) ||
-	    (hash = ((PyStringObject *) key)->ob_shash) == -1) {
+	if (!PyBytes_CheckExact(key) ||
+	    (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
 		hash = PyObject_Hash(key);
 		if (hash == -1)
 			return NULL;
@@ -1856,8 +1856,8 @@ dict_setdefault(register PyDictObject *mp, PyObject *args)
 	if (!PyArg_UnpackTuple(args, "setdefault", 1, 2, &key, &failobj))
 		return NULL;
 
-	if (!PyString_CheckExact(key) ||
-	    (hash = ((PyStringObject *) key)->ob_shash) == -1) {
+	if (!PyBytes_CheckExact(key) ||
+	    (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
 		hash = PyObject_Hash(key);
 		if (hash == -1)
 			return NULL;
@@ -1902,8 +1902,8 @@ dict_pop(PyDictObject *mp, PyObject *args)
 				"pop(): dictionary is empty");
 		return NULL;
 	}
-	if (!PyString_CheckExact(key) ||
-	    (hash = ((PyStringObject *) key)->ob_shash) == -1) {
+	if (!PyBytes_CheckExact(key) ||
+	    (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
 		hash = PyObject_Hash(key);
 		if (hash == -1)
 			return NULL;
@@ -2133,8 +2133,8 @@ PyDict_Contains(PyObject *op, PyObject *key)
 	PyDictObject *mp = (PyDictObject *)op;
 	PyDictEntry *ep;
 
-	if (!PyString_CheckExact(key) ||
-	    (hash = ((PyStringObject *) key)->ob_shash) == -1) {
+	if (!PyBytes_CheckExact(key) ||
+	    (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
 		hash = PyObject_Hash(key);
 		if (hash == -1)
 			return -1;
@@ -2260,7 +2260,7 @@ PyObject *
 PyDict_GetItemString(PyObject *v, const char *key)
 {
 	PyObject *kv, *rv;
-	kv = PyString_FromString(key);
+	kv = PyBytes_FromString(key);
 	if (kv == NULL)
 		return NULL;
 	rv = PyDict_GetItem(v, kv);
@@ -2273,10 +2273,10 @@ PyDict_SetItemString(PyObject *v, const char *key, PyObject *item)
 {
 	PyObject *kv;
 	int err;
-	kv = PyString_FromString(key);
+	kv = PyBytes_FromString(key);
 	if (kv == NULL)
 		return -1;
-	PyString_InternInPlace(&kv); /* XXX Should we really? */
+	PyBytes_InternInPlace(&kv); /* XXX Should we really? */
 	err = PyDict_SetItem(v, kv, item);
 	Py_DECREF(kv);
 	return err;
@@ -2287,7 +2287,7 @@ PyDict_DelItemString(PyObject *v, const char *key)
 {
 	PyObject *kv;
 	int err;
-	kv = PyString_FromString(key);
+	kv = PyBytes_FromString(key);
 	if (kv == NULL)
 		return -1;
 	err = PyDict_DelItem(v, kv);
diff --git a/Objects/exceptions.c b/Objects/exceptions.c
index 48b47b0..085ef36 100644
--- a/Objects/exceptions.c
+++ b/Objects/exceptions.c
@@ -44,7 +44,7 @@ BaseException_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
         return NULL;
     }
 
-    self->message = PyString_FromString("");
+    self->message = PyBytes_FromString("");
     if (!self->message) {
         Py_DECREF(self);
         return NULL;
@@ -104,7 +104,7 @@ BaseException_str(PyBaseExceptionObject *self)
 
     switch (PyTuple_GET_SIZE(self->args)) {
     case 0:
-        out = PyString_FromString("");
+        out = PyBytes_FromString("");
         break;
     case 1:
         out = PyObject_Str(PyTuple_GET_ITEM(self->args, 0));
@@ -133,13 +133,13 @@ BaseException_repr(PyBaseExceptionObject *self)
     dot = strrchr(name, '.');
     if (dot != NULL) name = dot+1;
 
-    repr = PyString_FromString(name);
+    repr = PyBytes_FromString(name);
     if (!repr) {
         Py_DECREF(repr_suffix);
         return NULL;
     }
 
-    PyString_ConcatAndDel(&repr, repr_suffix);
+    PyBytes_ConcatAndDel(&repr, repr_suffix);
     return repr;
 }
 
@@ -610,7 +610,7 @@ EnvironmentError_str(PyEnvironmentErrorObject *self)
         PyObject *repr;
         PyObject *tuple;
 
-        fmt = PyString_FromString("[Errno %s] %s: %s");
+        fmt = PyBytes_FromString("[Errno %s] %s: %s");
         if (!fmt)
             return NULL;
 
@@ -645,7 +645,7 @@ EnvironmentError_str(PyEnvironmentErrorObject *self)
 
         PyTuple_SET_ITEM(tuple, 2, repr);
 
-        rtnval = PyString_Format(fmt, tuple);
+        rtnval = PyBytes_Format(fmt, tuple);
 
         Py_DECREF(fmt);
         Py_DECREF(tuple);
@@ -654,7 +654,7 @@ EnvironmentError_str(PyEnvironmentErrorObject *self)
         PyObject *fmt;
         PyObject *tuple;
 
-        fmt = PyString_FromString("[Errno %s] %s");
+        fmt = PyBytes_FromString("[Errno %s] %s");
         if (!fmt)
             return NULL;
 
@@ -681,7 +681,7 @@ EnvironmentError_str(PyEnvironmentErrorObject *self)
             PyTuple_SET_ITEM(tuple, 1, Py_None);
         }
 
-        rtnval = PyString_Format(fmt, tuple);
+        rtnval = PyBytes_Format(fmt, tuple);
 
         Py_DECREF(fmt);
         Py_DECREF(tuple);
@@ -841,7 +841,7 @@ WindowsError_str(PyWindowsErrorObject *self)
         PyObject *repr;
         PyObject *tuple;
 
-        fmt = PyString_FromString("[Error %s] %s: %s");
+        fmt = PyBytes_FromString("[Error %s] %s: %s");
         if (!fmt)
             return NULL;
 
@@ -876,7 +876,7 @@ WindowsError_str(PyWindowsErrorObject *self)
 
         PyTuple_SET_ITEM(tuple, 2, repr);
 
-        rtnval = PyString_Format(fmt, tuple);
+        rtnval = PyBytes_Format(fmt, tuple);
 
         Py_DECREF(fmt);
         Py_DECREF(tuple);
@@ -885,7 +885,7 @@ WindowsError_str(PyWindowsErrorObject *self)
         PyObject *fmt;
         PyObject *tuple;
 
-        fmt = PyString_FromString("[Error %s] %s");
+        fmt = PyBytes_FromString("[Error %s] %s");
         if (!fmt)
             return NULL;
 
@@ -912,7 +912,7 @@ WindowsError_str(PyWindowsErrorObject *self)
             PyTuple_SET_ITEM(tuple, 1, Py_None);
         }
 
-        rtnval = PyString_Format(fmt, tuple);
+        rtnval = PyBytes_Format(fmt, tuple);
 
         Py_DECREF(fmt);
         Py_DECREF(tuple);
@@ -1109,21 +1109,21 @@ SyntaxError_str(PySyntaxErrorObject *self)
         str = PyObject_Str(Py_None);
     if (!str) return NULL;
     /* Don't fiddle with non-string return (shouldn't happen anyway) */
-    if (!PyString_Check(str)) return str;
+    if (!PyBytes_Check(str)) return str;
 
     /* XXX -- do all the additional formatting with filename and
        lineno here */
 
     have_filename = (self->filename != NULL) &&
-        PyString_Check(self->filename);
+        PyBytes_Check(self->filename);
     have_lineno = (self->lineno != NULL) && PyInt_Check(self->lineno);
 
     if (!have_filename && !have_lineno)
         return str;
 
-    bufsize = PyString_GET_SIZE(str) + 64;
+    bufsize = PyBytes_GET_SIZE(str) + 64;
     if (have_filename)
-        bufsize += PyString_GET_SIZE(self->filename);
+        bufsize += PyBytes_GET_SIZE(self->filename);
 
     buffer = PyMem_MALLOC(bufsize);
     if (buffer == NULL)
@@ -1131,19 +1131,19 @@ SyntaxError_str(PySyntaxErrorObject *self)
 
     if (have_filename && have_lineno)
         PyOS_snprintf(buffer, bufsize, "%s (%s, line %ld)",
-            PyString_AS_STRING(str),
-            my_basename(PyString_AS_STRING(self->filename)),
+            PyBytes_AS_STRING(str),
+            my_basename(PyBytes_AS_STRING(self->filename)),
             PyInt_AsLong(self->lineno));
     else if (have_filename)
         PyOS_snprintf(buffer, bufsize, "%s (%s)",
-            PyString_AS_STRING(str),
-            my_basename(PyString_AS_STRING(self->filename)));
+            PyBytes_AS_STRING(str),
+            my_basename(PyBytes_AS_STRING(self->filename)));
     else /* only have_lineno */
         PyOS_snprintf(buffer, bufsize, "%s (line %ld)",
-            PyString_AS_STRING(str),
+            PyBytes_AS_STRING(str),
             PyInt_AsLong(self->lineno));
 
-    result = PyString_FromString(buffer);
+    result = PyBytes_FromString(buffer);
     PyMem_FREE(buffer);
 
     if (result == NULL)
@@ -1250,7 +1250,7 @@ get_string(PyObject *attr, const char *name)
         return NULL;
     }
 
-    if (!PyString_Check(attr)) {
+    if (!PyBytes_Check(attr)) {
         PyErr_Format(PyExc_TypeError, "%.200s attribute must be str", name);
         return NULL;
     }
@@ -1262,7 +1262,7 @@ get_string(PyObject *attr, const char *name)
 static int
 set_string(PyObject **attr, const char *value)
 {
-    PyObject *obj = PyString_FromString(value);
+    PyObject *obj = PyBytes_FromString(value);
     if (!obj)
         return -1;
     Py_CLEAR(*attr);
@@ -1345,7 +1345,7 @@ PyUnicodeDecodeError_GetStart(PyObject *exc, Py_ssize_t *start)
                                "object");
     if (!obj)
         return -1;
-    size = PyString_GET_SIZE(obj);
+    size = PyBytes_GET_SIZE(obj);
     *start = ((PyUnicodeErrorObject *)exc)->start;
     if (*start<0)
         *start = 0;
@@ -1415,7 +1415,7 @@ PyUnicodeDecodeError_GetEnd(PyObject *exc, Py_ssize_t *end)
     if (!obj)
         return -1;
     *end = ((PyUnicodeErrorObject *)exc)->end;
-    size = PyString_GET_SIZE(obj);
+    size = PyBytes_GET_SIZE(obj);
     if (*end<1)
         *end = 1;
     if (*end>size)
@@ -1506,11 +1506,11 @@ UnicodeError_init(PyUnicodeErrorObject *self, PyObject *args, PyObject *kwds,
     Py_CLEAR(self->reason);
 
     if (!PyArg_ParseTuple(args, "O!O!nnO!",
-        &PyString_Type, &self->encoding,
+        &PyBytes_Type, &self->encoding,
         objecttype, &self->object,
         &self->start,
         &self->end,
-        &PyString_Type, &self->reason)) {
+        &PyBytes_Type, &self->reason)) {
         self->encoding = self->object = self->reason = NULL;
         return -1;
     }
@@ -1590,20 +1590,20 @@ UnicodeEncodeError_str(PyObject *self)
             PyOS_snprintf(badchar_str, sizeof(badchar_str), "u%04x", badchar);
         else
             PyOS_snprintf(badchar_str, sizeof(badchar_str), "U%08x", badchar);
-        return PyString_FromFormat(
+        return PyBytes_FromFormat(
             "'%.400s' codec can't encode character u'\\%s' in position %zd: %.400s",
-            PyString_AS_STRING(uself->encoding),
+            PyBytes_AS_STRING(uself->encoding),
             badchar_str,
             uself->start,
-            PyString_AS_STRING(uself->reason)
+            PyBytes_AS_STRING(uself->reason)
         );
     }
-    return PyString_FromFormat(
+    return PyBytes_FromFormat(
         "'%.400s' codec can't encode characters in position %zd-%zd: %.400s",
-        PyString_AS_STRING(uself->encoding),
+        PyBytes_AS_STRING(uself->encoding),
         uself->start,
         uself->end-1,
-        PyString_AS_STRING(uself->reason)
+        PyBytes_AS_STRING(uself->reason)
     );
 }
 
@@ -1642,7 +1642,7 @@ UnicodeDecodeError_init(PyObject *self, PyObject *args, PyObject *kwds)
     if (BaseException_init((PyBaseExceptionObject *)self, args, kwds) == -1)
         return -1;
     return UnicodeError_init((PyUnicodeErrorObject *)self, args,
-                             kwds, &PyString_Type);
+                             kwds, &PyBytes_Type);
 }
 
 static PyObject *
@@ -1654,21 +1654,21 @@ UnicodeDecodeError_str(PyObject *self)
         /* FromFormat does not support %02x, so format that separately */
         char byte[4];
         PyOS_snprintf(byte, sizeof(byte), "%02x",
-                      ((int)PyString_AS_STRING(uself->object)[uself->start])&0xff);
-        return PyString_FromFormat(
+                      ((int)PyBytes_AS_STRING(uself->object)[uself->start])&0xff);
+        return PyBytes_FromFormat(
             "'%.400s' codec can't decode byte 0x%s in position %zd: %.400s",
-            PyString_AS_STRING(uself->encoding),
+            PyBytes_AS_STRING(uself->encoding),
             byte,
             uself->start,
-            PyString_AS_STRING(uself->reason)
+            PyBytes_AS_STRING(uself->reason)
         );
     }
-    return PyString_FromFormat(
+    return PyBytes_FromFormat(
         "'%.400s' codec can't decode bytes in position %zd-%zd: %.400s",
-        PyString_AS_STRING(uself->encoding),
+        PyBytes_AS_STRING(uself->encoding),
         uself->start,
         uself->end-1,
-        PyString_AS_STRING(uself->reason)
+        PyBytes_AS_STRING(uself->reason)
     );
 }
 
@@ -1718,7 +1718,7 @@ UnicodeTranslateError_init(PyUnicodeErrorObject *self, PyObject *args,
         &PyUnicode_Type, &self->object,
         &self->start,
         &self->end,
-        &PyString_Type, &self->reason)) {
+        &PyBytes_Type, &self->reason)) {
         self->object = self->reason = NULL;
         return -1;
     }
@@ -1744,18 +1744,18 @@ UnicodeTranslateError_str(PyObject *self)
             PyOS_snprintf(badchar_str, sizeof(badchar_str), "u%04x", badchar);
         else
             PyOS_snprintf(badchar_str, sizeof(badchar_str), "U%08x", badchar);
-        return PyString_FromFormat(
+        return PyBytes_FromFormat(
             "can't translate character u'\\%s' in position %zd: %.400s",
             badchar_str,
             uself->start,
-            PyString_AS_STRING(uself->reason)
+            PyBytes_AS_STRING(uself->reason)
         );
     }
-    return PyString_FromFormat(
+    return PyBytes_FromFormat(
         "can't translate characters in position %zd-%zd: %.400s",
         uself->start,
         uself->end-1,
-        PyString_AS_STRING(uself->reason)
+        PyBytes_AS_STRING(uself->reason)
     );
 }
 
@@ -2111,7 +2111,7 @@ _PyExc_Init(void)
 	    (PyBaseExceptionObject *)PyExc_RecursionErrorInst;
 	PyObject *args_tuple;
 	PyObject *exc_message;
-	exc_message = PyString_FromString("maximum recursion depth exceeded");
+	exc_message = PyBytes_FromString("maximum recursion depth exceeded");
 	if (!exc_message)
 	    Py_FatalError("cannot allocate argument for RuntimeError "
 			    "pre-allocation");
diff --git a/Objects/fileobject.c b/Objects/fileobject.c
index 4f8c46b..86f3a14 100644
--- a/Objects/fileobject.c
+++ b/Objects/fileobject.c
@@ -26,7 +26,7 @@
 #include <io.h>
 #endif
 
-#define BUF(v) PyString_AS_STRING((PyStringObject *)v)
+#define BUF(v) PyBytes_AS_STRING((PyBytesObject *)v)
 
 #ifndef DONT_HAVE_ERRNO_H
 #include <errno.h>
@@ -159,7 +159,7 @@ fill_file_fields(PyFileObject *f, FILE *fp, PyObject *name, char *mode,
         Py_INCREF(name);
         f->f_name = name;
 
-	f->f_mode = PyString_FromString(mode);
+	f->f_mode = PyBytes_FromString(mode);
 
 	f->f_close = close;
 	f->f_softspace = 0;
@@ -367,7 +367,7 @@ PyFile_FromFile(FILE *fp, char *name, char *mode, int (*close)(FILE *))
 	PyFileObject *f = (PyFileObject *)PyFile_Type.tp_new(&PyFile_Type,
 							     NULL, NULL);
 	if (f != NULL) {
-		PyObject *o_name = PyString_FromString(name);
+		PyObject *o_name = PyBytes_FromString(name);
 		if (o_name == NULL)
 			return NULL;
 		if (fill_file_fields(f, fp, o_name, mode, close) == NULL) {
@@ -441,7 +441,7 @@ int
 PyFile_SetEncoding(PyObject *f, const char *enc)
 {
 	PyFileObject *file = (PyFileObject*)f;
-	PyObject *str = PyString_FromString(enc);
+	PyObject *str = PyBytes_FromString(enc);
 
 	assert(PyFile_Check(f));
 	if (!str)
@@ -502,20 +502,20 @@ file_repr(PyFileObject *f)
 #ifdef Py_USING_UNICODE
 		PyObject *ret = NULL;
 		PyObject *name = PyUnicode_AsUnicodeEscapeString(f->f_name);
-		const char *name_str = name ? PyString_AsString(name) : "?";
-		ret = PyString_FromFormat("<%s file u'%s', mode '%s' at %p>",
+		const char *name_str = name ? PyBytes_AsString(name) : "?";
+		ret = PyBytes_FromFormat("<%s file u'%s', mode '%s' at %p>",
 				   f->f_fp == NULL ? "closed" : "open",
 				   name_str,
-				   PyString_AsString(f->f_mode),
+				   PyBytes_AsString(f->f_mode),
 				   f);
 		Py_XDECREF(name);
 		return ret;
 #endif
 	} else {
-		return PyString_FromFormat("<%s file '%s', mode '%s' at %p>",
+		return PyBytes_FromFormat("<%s file '%s', mode '%s' at %p>",
 				   f->f_fp == NULL ? "closed" : "open",
-				   PyString_AsString(f->f_name),
-				   PyString_AsString(f->f_mode),
+				   PyBytes_AsString(f->f_name),
+				   PyBytes_AsString(f->f_mode),
 				   f);
 	}
 }
@@ -935,7 +935,7 @@ file_read(PyFileObject *f, PyObject *args)
 	"requested number of bytes is more than a Python string can hold");
 		return NULL;
 	}
-	v = PyString_FromStringAndSize((char *)NULL, buffersize);
+	v = PyBytes_FromStringAndSize((char *)NULL, buffersize);
 	if (v == NULL)
 		return NULL;
 	bytesread = 0;
@@ -966,7 +966,7 @@ file_read(PyFileObject *f, PyObject *args)
 		}
 		if (bytesrequested < 0) {
 			buffersize = new_buffersize(f, buffersize);
-			if (_PyString_Resize(&v, buffersize) < 0)
+			if (_PyBytes_Resize(&v, buffersize) < 0)
 				return NULL;
 		} else {
 			/* Got what was requested. */
@@ -974,7 +974,7 @@ file_read(PyFileObject *f, PyObject *args)
 		}
 	}
 	if (bytesread != buffersize)
-		_PyString_Resize(&v, bytesread);
+		_PyBytes_Resize(&v, bytesread);
 	return v;
 }
 
@@ -1092,7 +1092,7 @@ getline_via_fgets(PyFileObject *f, FILE *fp)
 	size_t increment;	/* amount to increment the buffer */
 	size_t prev_v_size;
 
-	/* Optimize for normal case:  avoid _PyString_Resize if at all
+	/* Optimize for normal case:  avoid _PyBytes_Resize if at all
 	 * possible via first reading into stack buffer "buf".
 	 */
 	total_v_size = INITBUFSIZE;	/* start small and pray */
@@ -1110,7 +1110,7 @@ getline_via_fgets(PyFileObject *f, FILE *fp)
 			clearerr(fp);
 			if (PyErr_CheckSignals())
 				return NULL;
-			v = PyString_FromStringAndSize(buf, pvfree - buf);
+			v = PyBytes_FromStringAndSize(buf, pvfree - buf);
 			return v;
 		}
 		/* fgets read *something* */
@@ -1139,7 +1139,7 @@ getline_via_fgets(PyFileObject *f, FILE *fp)
 				assert(p > pvfree && *(p-1) == '\0');
 				--p;	/* don't include \0 from fgets */
 			}
-			v = PyString_FromStringAndSize(buf, p - buf);
+			v = PyBytes_FromStringAndSize(buf, p - buf);
 			return v;
 		}
 		/* yuck:  fgets overwrote all the newlines, i.e. the entire
@@ -1160,7 +1160,7 @@ getline_via_fgets(PyFileObject *f, FILE *fp)
 	 * into its buffer.
 	 */
 	total_v_size = MAXBUFSIZE << 1;
-	v = PyString_FromStringAndSize((char*)NULL, (int)total_v_size);
+	v = PyBytes_FromStringAndSize((char*)NULL, (int)total_v_size);
 	if (v == NULL)
 		return v;
 	/* copy over everything except the last null byte */
@@ -1215,13 +1215,13 @@ getline_via_fgets(PyFileObject *f, FILE *fp)
 			Py_DECREF(v);
 			return NULL;
 		}
-		if (_PyString_Resize(&v, (int)total_v_size) < 0)
+		if (_PyBytes_Resize(&v, (int)total_v_size) < 0)
 			return NULL;
 		/* overwrite the trailing null byte */
 		pvfree = BUF(v) + (prev_v_size - 1);
 	}
 	if (BUF(v) + total_v_size != p)
-		_PyString_Resize(&v, p - BUF(v));
+		_PyBytes_Resize(&v, p - BUF(v));
 	return v;
 #undef INITBUFSIZE
 #undef MAXBUFSIZE
@@ -1253,7 +1253,7 @@ get_line(PyFileObject *f, int n)
 		return getline_via_fgets(f, fp);
 #endif
 	total_v_size = n > 0 ? n : 100;
-	v = PyString_FromStringAndSize((char *)NULL, total_v_size);
+	v = PyBytes_FromStringAndSize((char *)NULL, total_v_size);
 	if (v == NULL)
 		return NULL;
 	buf = BUF(v);
@@ -1326,7 +1326,7 @@ get_line(PyFileObject *f, int n)
 			Py_DECREF(v);
 			return NULL;
 		}
-		if (_PyString_Resize(&v, total_v_size) < 0)
+		if (_PyBytes_Resize(&v, total_v_size) < 0)
 			return NULL;
 		buf = BUF(v) + used_v_size;
 		end = BUF(v) + total_v_size;
@@ -1334,7 +1334,7 @@ get_line(PyFileObject *f, int n)
 
 	used_v_size = buf - BUF(v);
 	if (used_v_size != total_v_size)
-		_PyString_Resize(&v, used_v_size);
+		_PyBytes_Resize(&v, used_v_size);
 	return v;
 }
 
@@ -1379,7 +1379,7 @@ PyFile_GetLine(PyObject *f, int n)
 		result = PyEval_CallObject(reader, args);
 		Py_DECREF(reader);
 		Py_DECREF(args);
-		if (result != NULL && !PyString_Check(result) &&
+		if (result != NULL && !PyBytes_Check(result) &&
 		    !PyUnicode_Check(result)) {
 			Py_DECREF(result);
 			result = NULL;
@@ -1388,9 +1388,9 @@ PyFile_GetLine(PyObject *f, int n)
 		}
 	}
 
-	if (n < 0 && result != NULL && PyString_Check(result)) {
-		char *s = PyString_AS_STRING(result);
-		Py_ssize_t len = PyString_GET_SIZE(result);
+	if (n < 0 && result != NULL && PyBytes_Check(result)) {
+		char *s = PyBytes_AS_STRING(result);
+		Py_ssize_t len = PyBytes_GET_SIZE(result);
 		if (len == 0) {
 			Py_DECREF(result);
 			result = NULL;
@@ -1399,10 +1399,10 @@ PyFile_GetLine(PyObject *f, int n)
 		}
 		else if (s[len-1] == '\n') {
 			if (result->ob_refcnt == 1)
-				_PyString_Resize(&result, len-1);
+				_PyBytes_Resize(&result, len-1);
 			else {
 				PyObject *v;
-				v = PyString_FromStringAndSize(s, len-1);
+				v = PyBytes_FromStringAndSize(s, len-1);
 				Py_DECREF(result);
 				result = v;
 			}
@@ -1450,7 +1450,7 @@ file_readline(PyFileObject *f, PyObject *args)
 	if (!PyArg_ParseTuple(args, "|i:readline", &n))
 		return NULL;
 	if (n == 0)
-		return PyString_FromString("");
+		return PyBytes_FromString("");
 	if (n < 0)
 		n = 0;
 	return get_line(f, n);
@@ -1516,18 +1516,18 @@ file_readlines(PyFileObject *f, PyObject *args)
 			}
 			if (big_buffer == NULL) {
 				/* Create the big buffer */
-				big_buffer = PyString_FromStringAndSize(
+				big_buffer = PyBytes_FromStringAndSize(
 					NULL, buffersize);
 				if (big_buffer == NULL)
 					goto error;
-				buffer = PyString_AS_STRING(big_buffer);
+				buffer = PyBytes_AS_STRING(big_buffer);
 				memcpy(buffer, small_buffer, nfilled);
 			}
 			else {
 				/* Grow the big buffer */
-				if ( _PyString_Resize(&big_buffer, buffersize) < 0 )
+				if ( _PyBytes_Resize(&big_buffer, buffersize) < 0 )
 					goto error;
-				buffer = PyString_AS_STRING(big_buffer);
+				buffer = PyBytes_AS_STRING(big_buffer);
 			}
 			continue;
 		}
@@ -1536,7 +1536,7 @@ file_readlines(PyFileObject *f, PyObject *args)
 		do {
 			/* Process complete lines */
 			p++;
-			line = PyString_FromStringAndSize(q, p-q);
+			line = PyBytes_FromStringAndSize(q, p-q);
 			if (line == NULL)
 				goto error;
 			err = PyList_Append(list, line);
@@ -1555,7 +1555,7 @@ file_readlines(PyFileObject *f, PyObject *args)
 	}
 	if (nfilled != 0) {
 		/* Partial last line */
-		line = PyString_FromStringAndSize(buffer, nfilled);
+		line = PyBytes_FromStringAndSize(buffer, nfilled);
 		if (line == NULL)
 			goto error;
 		if (sizehint > 0) {
@@ -1565,7 +1565,7 @@ file_readlines(PyFileObject *f, PyObject *args)
 				Py_DECREF(line);
 				goto error;
 			}
-			PyString_Concat(&line, rest);
+			PyBytes_Concat(&line, rest);
 			Py_DECREF(rest);
 			if (line == NULL)
 				goto error;
@@ -1672,7 +1672,7 @@ file_writelines(PyFileObject *f, PyObject *seq)
 		   could potentially execute Python code. */
 		for (i = 0; i < j; i++) {
 			PyObject *v = PyList_GET_ITEM(list, i);
-			if (!PyString_Check(v)) {
+			if (!PyBytes_Check(v)) {
 			    	const char *buffer;
 				if (((f->f_binary &&
 				      PyObject_AsReadBuffer(v,
@@ -1685,7 +1685,7 @@ file_writelines(PyFileObject *f, PyObject *seq)
 			"writelines() argument must be a sequence of strings");
 					goto error;
 				}
-				line = PyString_FromStringAndSize(buffer,
+				line = PyBytes_FromStringAndSize(buffer,
 								  len);
 				if (line == NULL)
 					goto error;
@@ -1701,8 +1701,8 @@ file_writelines(PyFileObject *f, PyObject *seq)
 		errno = 0;
 		for (i = 0; i < j; i++) {
 		    	line = PyList_GET_ITEM(list, i);
-			len = PyString_GET_SIZE(line);
-			nwritten = fwrite(PyString_AS_STRING(line),
+			len = PyBytes_GET_SIZE(line);
+			nwritten = fwrite(PyBytes_AS_STRING(line),
 					  1, len, f->f_fp);
 			if (nwritten != len) {
 				FILE_ABORT_ALLOW_THREADS(f)
@@ -1896,13 +1896,13 @@ get_newlines(PyFileObject *f, void *closure)
 		Py_INCREF(Py_None);
 		return Py_None;
 	case NEWLINE_CR:
-		return PyString_FromString("\r");
+		return PyBytes_FromString("\r");
 	case NEWLINE_LF:
-		return PyString_FromString("\n");
+		return PyBytes_FromString("\n");
 	case NEWLINE_CR|NEWLINE_LF:
 		return Py_BuildValue("(ss)", "\r", "\n");
 	case NEWLINE_CRLF:
-		return PyString_FromString("\r\n");
+		return PyBytes_FromString("\r\n");
 	case NEWLINE_CR|NEWLINE_CRLF:
 		return Py_BuildValue("(ss)", "\r", "\r\n");
 	case NEWLINE_LF|NEWLINE_CRLF:
@@ -2004,10 +2004,10 @@ readahead(PyFileObject *f, int bufsize)
    horrified by the recursive call: maximum recursion depth is limited by
    logarithmic buffer growth to about 50 even when reading a 1gb line. */
 
-static PyStringObject *
+static PyBytesObject *
 readahead_get_line_skip(PyFileObject *f, int skip, int bufsize)
 {
-	PyStringObject* s;
+	PyBytesObject* s;
 	char *bufptr;
 	char *buf;
 	Py_ssize_t len;
@@ -2018,17 +2018,17 @@ readahead_get_line_skip(PyFileObject *f, int skip, int bufsize)
 
 	len = f->f_bufend - f->f_bufptr;
 	if (len == 0)
-		return (PyStringObject *)
-			PyString_FromStringAndSize(NULL, skip);
+		return (PyBytesObject *)
+			PyBytes_FromStringAndSize(NULL, skip);
 	bufptr = (char *)memchr(f->f_bufptr, '\n', len);
 	if (bufptr != NULL) {
 		bufptr++;			/* Count the '\n' */
 		len = bufptr - f->f_bufptr;
-		s = (PyStringObject *)
-			PyString_FromStringAndSize(NULL, skip+len);
+		s = (PyBytesObject *)
+			PyBytes_FromStringAndSize(NULL, skip+len);
 		if (s == NULL)
 			return NULL;
-		memcpy(PyString_AS_STRING(s)+skip, f->f_bufptr, len);
+		memcpy(PyBytes_AS_STRING(s)+skip, f->f_bufptr, len);
 		f->f_bufptr = bufptr;
 		if (bufptr == f->f_bufend)
 			drop_readahead(f);
@@ -2043,7 +2043,7 @@ readahead_get_line_skip(PyFileObject *f, int skip, int bufsize)
 		        PyMem_Free(buf);
 			return NULL;
 		}
-		memcpy(PyString_AS_STRING(s)+skip, bufptr, len);
+		memcpy(PyBytes_AS_STRING(s)+skip, bufptr, len);
 		PyMem_Free(buf);
 	}
 	return s;
@@ -2055,13 +2055,13 @@ readahead_get_line_skip(PyFileObject *f, int skip, int bufsize)
 static PyObject *
 file_iternext(PyFileObject *f)
 {
-	PyStringObject* l;
+	PyBytesObject* l;
 
 	if (f->f_fp == NULL)
 		return err_closed();
 
 	l = readahead_get_line_skip(f, 0, READAHEAD_BUFSIZE);
-	if (l == NULL || PyString_GET_SIZE(l) == 0) {
+	if (l == NULL || PyBytes_GET_SIZE(l) == 0) {
 		Py_XDECREF(l);
 		return NULL;
 	}
@@ -2078,7 +2078,7 @@ file_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 	assert(type != NULL && type->tp_alloc != NULL);
 
 	if (not_yet_string == NULL) {
-		not_yet_string = PyString_InternFromString("<uninitialized file>");
+		not_yet_string = PyBytes_InternFromString("<uninitialized file>");
 		if (not_yet_string == NULL)
 			return NULL;
 	}
@@ -2294,7 +2294,7 @@ PyFile_WriteObject(PyObject *v, PyObject *f, int flags)
 #ifdef Py_USING_UNICODE
                 if ((flags & Py_PRINT_RAW) &&
 		    PyUnicode_Check(v) && enc != Py_None) {
-			char *cenc = PyString_AS_STRING(enc);
+			char *cenc = PyBytes_AS_STRING(enc);
 			value = PyUnicode_AsEncodedString(v, cenc, "strict");
 			if (value == NULL)
 				return -1;
@@ -2365,7 +2365,7 @@ PyFile_WriteString(const char *s, PyObject *f)
 		return 0;
 	}
 	else if (!PyErr_Occurred()) {
-		PyObject *v = PyString_FromString(s);
+		PyObject *v = PyBytes_FromString(s);
 		int err;
 		if (v == NULL)
 			return -1;
diff --git a/Objects/floatobject.c b/Objects/floatobject.c
index ceb0b6d..3b49341 100644
--- a/Objects/floatobject.c
+++ b/Objects/floatobject.c
@@ -185,9 +185,9 @@ PyFloat_FromString(PyObject *v, char **pend)
 
 	if (pend)
 		*pend = NULL;
-	if (PyString_Check(v)) {
-		s = PyString_AS_STRING(v);
-		len = PyString_GET_SIZE(v);
+	if (PyBytes_Check(v)) {
+		s = PyBytes_AS_STRING(v);
+		len = PyBytes_GET_SIZE(v);
 	}
 #ifdef Py_USING_UNICODE
 	else if (PyUnicode_Check(v)) {
@@ -488,7 +488,7 @@ float_repr(PyFloatObject *v)
 	char buf[100];
 	format_float(buf, sizeof(buf), v, PREC_REPR);
 
-	return PyString_FromString(buf);
+	return PyBytes_FromString(buf);
 }
 
 static PyObject *
@@ -496,7 +496,7 @@ float_str(PyFloatObject *v)
 {
 	char buf[100];
 	format_float(buf, sizeof(buf), v, PREC_STR);
-	return PyString_FromString(buf);
+	return PyBytes_FromString(buf);
 }
 
 /* Comparison is pretty much a nightmare.  When comparing float to float,
@@ -1221,7 +1221,7 @@ float_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 		return float_subtype_new(type, args, kwds); /* Wimp out */
 	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:float", kwlist, &x))
 		return NULL;
-	if (PyString_Check(x))
+	if (PyBytes_Check(x))
 		return PyFloat_FromString(x, NULL);
 	return PyNumber_Float(x);
 }
@@ -1272,13 +1272,13 @@ float_getformat(PyTypeObject *v, PyObject* arg)
 	char* s;
 	float_format_type r;
 
-	if (!PyString_Check(arg)) {
+	if (!PyBytes_Check(arg)) {
 		PyErr_Format(PyExc_TypeError,
 	     "__getformat__() argument must be string, not %.500s",
 			     Py_TYPE(arg)->tp_name);
 		return NULL;
 	}
-	s = PyString_AS_STRING(arg);
+	s = PyBytes_AS_STRING(arg);
 	if (strcmp(s, "double") == 0) {
 		r = double_format;
 	}
@@ -1294,11 +1294,11 @@ float_getformat(PyTypeObject *v, PyObject* arg)
 	
 	switch (r) {
 	case unknown_format:
-		return PyString_FromString("unknown");
+		return PyBytes_FromString("unknown");
 	case ieee_little_endian_format:
-		return PyString_FromString("IEEE, little-endian");
+		return PyBytes_FromString("IEEE, little-endian");
 	case ieee_big_endian_format:
-		return PyString_FromString("IEEE, big-endian");
+		return PyBytes_FromString("IEEE, big-endian");
 	default:
 		Py_FatalError("insane float_format or double_format");
 		return NULL;
@@ -1397,7 +1397,7 @@ float__format__(PyObject *self, PyObject *args)
 
 	if (!PyArg_ParseTuple(args, "O:__format__", &format_spec))
 		return NULL;
-	if (PyString_Check(format_spec))
+	if (PyBytes_Check(format_spec))
 		return string_float__format__(self, args);
 	if (PyUnicode_Check(format_spec)) {
 		/* Convert format_spec to a str */
diff --git a/Objects/frameobject.c b/Objects/frameobject.c
index 025431e..36c1fc2 100644
--- a/Objects/frameobject.c
+++ b/Objects/frameobject.c
@@ -114,7 +114,7 @@ frame_setlineno(PyFrameObject *f, PyObject* p_new_lineno)
 
 	/* Find the bytecode offset for the start of the given line, or the
 	 * first code-owning line after it. */
-	PyString_AsStringAndSize(f->f_code->co_lnotab, &lnotab, &lnotab_len);
+	PyBytes_AsStringAndSize(f->f_code->co_lnotab, &lnotab, &lnotab_len);
 	addr = 0;
 	line = f->f_code->co_firstlineno;
 	new_lasti = -1;
@@ -137,7 +137,7 @@ frame_setlineno(PyFrameObject *f, PyObject* p_new_lineno)
 	}
 
 	/* We're now ready to look at the bytecode. */
-	PyString_AsStringAndSize(f->f_code->co_code, (char **)&code, &code_len);
+	PyBytes_AsStringAndSize(f->f_code->co_code, (char **)&code, &code_len);
 	min_addr = MIN(new_lasti, f->f_lasti);
 	max_addr = MAX(new_lasti, f->f_lasti);
 
@@ -548,7 +548,7 @@ static PyObject *builtin_object;
 
 int _PyFrame_Init()
 {
-	builtin_object = PyString_InternFromString("__builtins__");
+	builtin_object = PyBytes_InternFromString("__builtins__");
 	return (builtin_object != NULL);
 }
 
@@ -728,7 +728,7 @@ map_to_dict(PyObject *map, Py_ssize_t nmap, PyObject *dict, PyObject **values,
 	for (j = nmap; --j >= 0; ) {
 		PyObject *key = PyTuple_GET_ITEM(map, j);
 		PyObject *value = values[j];
-		assert(PyString_Check(key));
+		assert(PyBytes_Check(key));
 		if (deref) {
 			assert(PyCell_Check(value));
 			value = PyCell_GET(value);
@@ -776,7 +776,7 @@ dict_to_map(PyObject *map, Py_ssize_t nmap, PyObject *dict, PyObject **values,
 	for (j = nmap; --j >= 0; ) {
 		PyObject *key = PyTuple_GET_ITEM(map, j);
 		PyObject *value = PyObject_GetItem(dict, key);
-		assert(PyString_Check(key));
+		assert(PyBytes_Check(key));
 		/* We only care about NULLs if clear is true. */
 		if (value == NULL) {
 			PyErr_Clear();
diff --git a/Objects/funcobject.c b/Objects/funcobject.c
index a2e87b7..216b6da 100644
--- a/Objects/funcobject.c
+++ b/Objects/funcobject.c
@@ -28,7 +28,7 @@ PyFunction_New(PyObject *code, PyObject *globals)
 		consts = ((PyCodeObject *)code)->co_consts;
 		if (PyTuple_Size(consts) >= 1) {
 			doc = PyTuple_GetItem(consts, 0);
-			if (!PyString_Check(doc) && !PyUnicode_Check(doc))
+			if (!PyBytes_Check(doc) && !PyUnicode_Check(doc))
 				doc = Py_None;
 		}
 		else
@@ -42,7 +42,7 @@ PyFunction_New(PyObject *code, PyObject *globals)
 		   Otherwise, use None.
 		*/
 		if (!__name__) {
-			__name__ = PyString_InternFromString("__name__");
+			__name__ = PyBytes_InternFromString("__name__");
 			if (!__name__) {
 				Py_DECREF(op);
 				return NULL;
@@ -254,7 +254,7 @@ func_set_code(PyFunctionObject *op, PyObject *value)
 		PyErr_Format(PyExc_ValueError,
 			     "%s() requires a code object with %zd free vars,"
 			     " not %zd",
-			     PyString_AsString(op->func_name),
+			     PyBytes_AsString(op->func_name),
 			     nclosure, nfree);
 		return -1;
 	}
@@ -281,7 +281,7 @@ func_set_name(PyFunctionObject *op, PyObject *value)
 		return -1;
 	/* Not legal to del f.func_name or to set it to anything
 	 * other than a string object. */
-	if (value == NULL || !PyString_Check(value)) {
+	if (value == NULL || !PyBytes_Check(value)) {
 		PyErr_SetString(PyExc_TypeError,
 				"__name__ must be set to a string object");
 		return -1;
@@ -380,7 +380,7 @@ func_new(PyTypeObject* type, PyObject* args, PyObject* kw)
 			      &PyDict_Type, &globals,
 			      &name, &defaults, &closure))
 		return NULL;
-	if (name != Py_None && !PyString_Check(name)) {
+	if (name != Py_None && !PyBytes_Check(name)) {
 		PyErr_SetString(PyExc_TypeError,
 				"arg 3 (name) must be None or string");
 		return NULL;
@@ -409,7 +409,7 @@ func_new(PyTypeObject* type, PyObject* args, PyObject* kw)
 	if (nfree != nclosure)
 		return PyErr_Format(PyExc_ValueError,
 				    "%s requires closure of length %zd, not %zd",
-				    PyString_AS_STRING(code->co_name),
+				    PyBytes_AS_STRING(code->co_name),
 				    nfree, nclosure);
 	if (nclosure) {
 		Py_ssize_t i;
@@ -465,8 +465,8 @@ func_dealloc(PyFunctionObject *op)
 static PyObject*
 func_repr(PyFunctionObject *op)
 {
-	return PyString_FromFormat("<function %s at %p>",
-				   PyString_AsString(op->func_name),
+	return PyBytes_FromFormat("<function %s at %p>",
+				   PyBytes_AsString(op->func_name),
 				   op);
 }
 
diff --git a/Objects/genobject.c b/Objects/genobject.c
index d2ef508..b1c51a8 100644
--- a/Objects/genobject.c
+++ b/Objects/genobject.c
@@ -285,10 +285,10 @@ static PyObject *
 gen_repr(PyGenObject *gen)
 {
 	char *code_name;
-	code_name = PyString_AsString(((PyCodeObject *)gen->gi_code)->co_name);
+	code_name = PyBytes_AsString(((PyCodeObject *)gen->gi_code)->co_name);
 	if (code_name == NULL)
 		return NULL;
-	return PyString_FromFormat("<generator object %.200s at %p>",
+	return PyBytes_FromFormat("<generator object %.200s at %p>",
 				   code_name, gen);
 }
 
diff --git a/Objects/intobject.c b/Objects/intobject.c
index eacad9d..2af9451 100644
--- a/Objects/intobject.c
+++ b/Objects/intobject.c
@@ -368,7 +368,7 @@ PyInt_FromString(char *s, char **pend, int base)
 	if (*end != '\0') {
   bad:
 		slen = strlen(s) < 200 ? strlen(s) : 200;
-		sobj = PyString_FromStringAndSize(s, slen);
+		sobj = PyBytes_FromStringAndSize(s, slen);
 		if (sobj == NULL)
 			return NULL;
 		srepr = PyObject_Repr(sobj);
@@ -377,7 +377,7 @@ PyInt_FromString(char *s, char **pend, int base)
 			return NULL;
 		PyErr_Format(PyExc_ValueError,
 			     "invalid literal for int() with base %d: %s",
-			     base, PyString_AS_STRING(srepr));
+			     base, PyBytes_AS_STRING(srepr));
 		Py_DECREF(srepr);
 		return NULL;
 	}
@@ -965,11 +965,11 @@ int_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 		return PyInt_FromLong(0L);
 	if (base == -909)
 		return PyNumber_Int(x);
-	if (PyString_Check(x)) {
+	if (PyBytes_Check(x)) {
 		/* Since PyInt_FromString doesn't have a length parameter,
 		 * check here for possible NULs in the string. */
-		char *string = PyString_AS_STRING(x);
-		if (strlen(string) != PyString_Size(x)) {
+		char *string = PyBytes_AS_STRING(x);
+		if (strlen(string) != PyBytes_Size(x)) {
 			/* create a repr() of the input string,
 			 * just like PyInt_FromString does */
 			PyObject *srepr;
@@ -978,7 +978,7 @@ int_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 				return NULL;
 			PyErr_Format(PyExc_ValueError,
 			     "invalid literal for int() with base %d: %s",
-			     base, PyString_AS_STRING(srepr));
+			     base, PyBytes_AS_STRING(srepr));
 			Py_DECREF(srepr);
 			return NULL;
 		}
@@ -1106,7 +1106,7 @@ _PyInt_Format(PyIntObject *v, int base, int newstyle)
 	if (negative)
 		*--p = '-';
 
-	return PyString_FromStringAndSize(p, &buf[sizeof(buf)] - p);
+	return PyBytes_FromStringAndSize(p, &buf[sizeof(buf)] - p);
 }
 
 static PyObject *
@@ -1116,7 +1116,7 @@ int__format__(PyObject *self, PyObject *args)
 
 	if (!PyArg_ParseTuple(args, "O:__format__", &format_spec))
 		return NULL;
-	if (PyString_Check(format_spec))
+	if (PyBytes_Check(format_spec))
 		return string_int__format__(self, args);
 	if (PyUnicode_Check(format_spec)) {
 		/* Convert format_spec to a str */
diff --git a/Objects/listobject.c b/Objects/listobject.c
index ee2fda1..9d742d8 100644
--- a/Objects/listobject.c
+++ b/Objects/listobject.c
@@ -174,7 +174,7 @@ PyList_GetItem(PyObject *op, Py_ssize_t i)
 	}
 	if (i < 0 || i >= Py_SIZE(op)) {
 		if (indexerr == NULL)
-			indexerr = PyString_FromString(
+			indexerr = PyBytes_FromString(
 				"list index out of range");
 		PyErr_SetObject(PyExc_IndexError, indexerr);
 		return NULL;
@@ -349,11 +349,11 @@ list_repr(PyListObject *v)
 
 	i = Py_ReprEnter((PyObject*)v);
 	if (i != 0) {
-		return i > 0 ? PyString_FromString("[...]") : NULL;
+		return i > 0 ? PyBytes_FromString("[...]") : NULL;
 	}
 
 	if (Py_SIZE(v) == 0) {
-		result = PyString_FromString("[]");
+		result = PyBytes_FromString("[]");
 		goto Done;
 	}
 
@@ -379,29 +379,29 @@ list_repr(PyListObject *v)
 
 	/* Add "[]" decorations to the first and last items. */
 	assert(PyList_GET_SIZE(pieces) > 0);
-	s = PyString_FromString("[");
+	s = PyBytes_FromString("[");
 	if (s == NULL)
 		goto Done;
 	temp = PyList_GET_ITEM(pieces, 0);
-	PyString_ConcatAndDel(&s, temp);
+	PyBytes_ConcatAndDel(&s, temp);
 	PyList_SET_ITEM(pieces, 0, s);
 	if (s == NULL)
 		goto Done;
 
-	s = PyString_FromString("]");
+	s = PyBytes_FromString("]");
 	if (s == NULL)
 		goto Done;
 	temp = PyList_GET_ITEM(pieces, PyList_GET_SIZE(pieces) - 1);
-	PyString_ConcatAndDel(&temp, s);
+	PyBytes_ConcatAndDel(&temp, s);
 	PyList_SET_ITEM(pieces, PyList_GET_SIZE(pieces) - 1, temp);
 	if (temp == NULL)
 		goto Done;
 
 	/* Paste them all together with ", " between. */
-	s = PyString_FromString(", ");
+	s = PyBytes_FromString(", ");
 	if (s == NULL)
 		goto Done;
-	result = _PyString_Join(s, pieces);
+	result = _PyBytes_Join(s, pieces);
 	Py_DECREF(s);
 
 Done:
@@ -433,7 +433,7 @@ list_item(PyListObject *a, Py_ssize_t i)
 {
 	if (i < 0 || i >= Py_SIZE(a)) {
 		if (indexerr == NULL)
-			indexerr = PyString_FromString(
+			indexerr = PyBytes_FromString(
 				"list index out of range");
 		PyErr_SetObject(PyExc_IndexError, indexerr);
 		return NULL;
diff --git a/Objects/longobject.c b/Objects/longobject.c
index 7fc4576..5922aa5 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -1200,7 +1200,7 @@ PyAPI_FUNC(PyObject *)
 _PyLong_Format(PyObject *aa, int base, int addL, int newstyle)
 {
 	register PyLongObject *a = (PyLongObject *)aa;
-	PyStringObject *str;
+	PyBytesObject *str;
 	Py_ssize_t i, j, sz;
 	Py_ssize_t size_a;
 	char *p;
@@ -1229,10 +1229,10 @@ _PyLong_Format(PyObject *aa, int base, int addL, int newstyle)
 				"long is too large to format");
 		return NULL;
 	}
-	str = (PyStringObject *) PyString_FromStringAndSize((char *)0, sz);
+	str = (PyBytesObject *) PyBytes_FromStringAndSize((char *)0, sz);
 	if (str == NULL)
 		return NULL;
-	p = PyString_AS_STRING(str) + sz;
+	p = PyBytes_AS_STRING(str) + sz;
 	*p = '\0';
         if (addL)
                 *--p = 'L';
@@ -1258,7 +1258,7 @@ _PyLong_Format(PyObject *aa, int base, int addL, int newstyle)
 			do {
 				char cdigit = (char)(accum & (base - 1));
 				cdigit += (cdigit < 10) ? '0' : 'a'-10;
-				assert(p > PyString_AS_STRING(str));
+				assert(p > PyBytes_AS_STRING(str));
 				*--p = cdigit;
 				accumbits -= basebits;
 				accum >>= basebits;
@@ -1310,7 +1310,7 @@ _PyLong_Format(PyObject *aa, int base, int addL, int newstyle)
 			do {
 				digit nextrem = (digit)(rem / base);
 				char c = (char)(rem - nextrem * base);
-				assert(p > PyString_AS_STRING(str));
+				assert(p > PyBytes_AS_STRING(str));
 				c += (c < 10) ? '0' : 'a'-10;
 				*--p = c;
 				rem = nextrem;
@@ -1348,14 +1348,14 @@ _PyLong_Format(PyObject *aa, int base, int addL, int newstyle)
 	}
 	if (sign)
 		*--p = sign;
-	if (p != PyString_AS_STRING(str)) {
-		char *q = PyString_AS_STRING(str);
+	if (p != PyBytes_AS_STRING(str)) {
+		char *q = PyBytes_AS_STRING(str);
 		assert(p > q);
 		do {
 		} while ((*q++ = *p++) != '\0');
 		q--;
-		_PyString_Resize((PyObject **)&str,
-				 (Py_ssize_t) (q - PyString_AS_STRING(str)));
+		_PyBytes_Resize((PyObject **)&str,
+				 (Py_ssize_t) (q - PyBytes_AS_STRING(str)));
 	}
 	return (PyObject *)str;
 }
@@ -1719,7 +1719,7 @@ digit beyond the first.
  onError:
 	Py_XDECREF(z);
 	slen = strlen(orig_str) < 200 ? strlen(orig_str) : 200;
-	strobj = PyString_FromStringAndSize(orig_str, slen);
+	strobj = PyBytes_FromStringAndSize(orig_str, slen);
 	if (strobj == NULL)
 		return NULL;
 	strrepr = PyObject_Repr(strobj);
@@ -1728,7 +1728,7 @@ digit beyond the first.
 		return NULL;
 	PyErr_Format(PyExc_ValueError,
 		     "invalid literal for long() with base %d: %s",
-		     base, PyString_AS_STRING(strrepr));
+		     base, PyBytes_AS_STRING(strrepr));
 	Py_DECREF(strrepr);
 	return NULL;
 }
@@ -3332,11 +3332,11 @@ long_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 		return PyLong_FromLong(0L);
 	if (base == -909)
 		return PyNumber_Long(x);
-	else if (PyString_Check(x)) {
+	else if (PyBytes_Check(x)) {
 		/* Since PyLong_FromString doesn't have a length parameter,
 		 * check here for possible NULs in the string. */
-		char *string = PyString_AS_STRING(x);
-		if (strlen(string) != PyString_Size(x)) {
+		char *string = PyBytes_AS_STRING(x);
+		if (strlen(string) != PyBytes_Size(x)) {
 			/* create a repr() of the input string,
 			 * just like PyLong_FromString does. */
 			PyObject *srepr;
@@ -3345,11 +3345,11 @@ long_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 				return NULL;
 			PyErr_Format(PyExc_ValueError,
 			     "invalid literal for long() with base %d: %s",
-			     base, PyString_AS_STRING(srepr));
+			     base, PyBytes_AS_STRING(srepr));
 			Py_DECREF(srepr);
 			return NULL;
 		}
-		return PyLong_FromString(PyString_AS_STRING(x), NULL, base);
+		return PyLong_FromString(PyBytes_AS_STRING(x), NULL, base);
 	}
 #ifdef Py_USING_UNICODE
 	else if (PyUnicode_Check(x))
@@ -3414,7 +3414,7 @@ long__format__(PyObject *self, PyObject *args)
 
 	if (!PyArg_ParseTuple(args, "O:__format__", &format_spec))
 		return NULL;
-	if (PyString_Check(format_spec))
+	if (PyBytes_Check(format_spec))
 		return string_long__format__(self, args);
 	if (PyUnicode_Check(format_spec)) {
 		/* Convert format_spec to a str */
diff --git a/Objects/methodobject.c b/Objects/methodobject.c
index 737a3f7..57ab5c5 100644
--- a/Objects/methodobject.c
+++ b/Objects/methodobject.c
@@ -149,7 +149,7 @@ meth_get__doc__(PyCFunctionObject *m, void *closure)
 	const char *doc = m->m_ml->ml_doc;
 
 	if (doc != NULL)
-		return PyString_FromString(doc);
+		return PyBytes_FromString(doc);
 	Py_INCREF(Py_None);
 	return Py_None;
 }
@@ -157,7 +157,7 @@ meth_get__doc__(PyCFunctionObject *m, void *closure)
 static PyObject *
 meth_get__name__(PyCFunctionObject *m, void *closure)
 {
-	return PyString_FromString(m->m_ml->ml_name);
+	return PyBytes_FromString(m->m_ml->ml_name);
 }
 
 static int
@@ -202,9 +202,9 @@ static PyObject *
 meth_repr(PyCFunctionObject *m)
 {
 	if (m->m_self == NULL)
-		return PyString_FromFormat("<built-in function %s>",
+		return PyBytes_FromFormat("<built-in function %s>",
 					   m->m_ml->ml_name);
-	return PyString_FromFormat("<built-in method %s of %s object at %p>",
+	return PyBytes_FromFormat("<built-in method %s of %s object at %p>",
 				   m->m_ml->ml_name,
 				   m->m_self->ob_type->tp_name,
 				   m->m_self);
@@ -333,7 +333,7 @@ listmethodchain(PyMethodChain *chain)
 	i = 0;
 	for (c = chain; c != NULL; c = c->link) {
 		for (ml = c->methods; ml->ml_name != NULL; ml++) {
-			PyList_SetItem(v, i, PyString_FromString(ml->ml_name));
+			PyList_SetItem(v, i, PyBytes_FromString(ml->ml_name));
 			i++;
 		}
 	}
@@ -360,7 +360,7 @@ Py_FindMethodInChain(PyMethodChain *chain, PyObject *self, const char *name)
 		if (strcmp(name, "__doc__") == 0) {
 			const char *doc = self->ob_type->tp_doc;
 			if (doc != NULL)
-				return PyString_FromString(doc);
+				return PyBytes_FromString(doc);
 		}
 	}
 	while (chain != NULL) {
diff --git a/Objects/moduleobject.c b/Objects/moduleobject.c
index d1aa771..fa3daa9 100644
--- a/Objects/moduleobject.c
+++ b/Objects/moduleobject.c
@@ -22,7 +22,7 @@ PyModule_New(const char *name)
 	m = PyObject_GC_New(PyModuleObject, &PyModule_Type);
 	if (m == NULL)
 		return NULL;
-	nameobj = PyString_FromString(name);
+	nameobj = PyBytes_FromString(name);
 	m->md_dict = PyDict_New();
 	if (m->md_dict == NULL || nameobj == NULL)
 		goto fail;
@@ -68,12 +68,12 @@ PyModule_GetName(PyObject *m)
 	d = ((PyModuleObject *)m)->md_dict;
 	if (d == NULL ||
 	    (nameobj = PyDict_GetItemString(d, "__name__")) == NULL ||
-	    !PyString_Check(nameobj))
+	    !PyBytes_Check(nameobj))
 	{
 		PyErr_SetString(PyExc_SystemError, "nameless module");
 		return NULL;
 	}
-	return PyString_AsString(nameobj);
+	return PyBytes_AsString(nameobj);
 }
 
 char *
@@ -88,12 +88,12 @@ PyModule_GetFilename(PyObject *m)
 	d = ((PyModuleObject *)m)->md_dict;
 	if (d == NULL ||
 	    (fileobj = PyDict_GetItemString(d, "__file__")) == NULL ||
-	    !PyString_Check(fileobj))
+	    !PyBytes_Check(fileobj))
 	{
 		PyErr_SetString(PyExc_SystemError, "module filename missing");
 		return NULL;
 	}
-	return PyString_AsString(fileobj);
+	return PyBytes_AsString(fileobj);
 }
 
 void
@@ -117,8 +117,8 @@ _PyModule_Clear(PyObject *m)
 	/* First, clear only names starting with a single underscore */
 	pos = 0;
 	while (PyDict_Next(d, &pos, &key, &value)) {
-		if (value != Py_None && PyString_Check(key)) {
-			char *s = PyString_AsString(key);
+		if (value != Py_None && PyBytes_Check(key)) {
+			char *s = PyBytes_AsString(key);
 			if (s[0] == '_' && s[1] != '_') {
 				if (Py_VerboseFlag > 1)
 				    PySys_WriteStderr("#   clear[1] %s\n", s);
@@ -130,8 +130,8 @@ _PyModule_Clear(PyObject *m)
 	/* Next, clear all names except for __builtins__ */
 	pos = 0;
 	while (PyDict_Next(d, &pos, &key, &value)) {
-		if (value != Py_None && PyString_Check(key)) {
-			char *s = PyString_AsString(key);
+		if (value != Py_None && PyBytes_Check(key)) {
+			char *s = PyBytes_AsString(key);
 			if (s[0] != '_' || strcmp(s, "__builtins__") != 0) {
 				if (Py_VerboseFlag > 1)
 				    PySys_WriteStderr("#   clear[2] %s\n", s);
@@ -195,9 +195,9 @@ module_repr(PyModuleObject *m)
 	filename = PyModule_GetFilename((PyObject *)m);
 	if (filename == NULL) {
 		PyErr_Clear();
-		return PyString_FromFormat("<module '%s' (built-in)>", name);
+		return PyBytes_FromFormat("<module '%s' (built-in)>", name);
 	}
-	return PyString_FromFormat("<module '%s' from '%s'>", name, filename);
+	return PyBytes_FromFormat("<module '%s' from '%s'>", name, filename);
 }
 
 /* We only need a traverse function, no clear function: If the module
diff --git a/Objects/object.c b/Objects/object.c
index ccb5ab7..8f9d731 100644
--- a/Objects/object.c
+++ b/Objects/object.c
@@ -357,9 +357,9 @@ PyObject_Repr(PyObject *v)
 	}
 #endif
 	if (v == NULL)
-		return PyString_FromString("<NULL>");
+		return PyBytes_FromString("<NULL>");
 	else if (Py_TYPE(v)->tp_repr == NULL)
-		return PyString_FromFormat("<%s object at %p>",
+		return PyBytes_FromFormat("<%s object at %p>",
 					   Py_TYPE(v)->tp_name, v);
 	else {
 		PyObject *res;
@@ -377,7 +377,7 @@ PyObject_Repr(PyObject *v)
 				return NULL;
 		}
 #endif
-		if (!PyString_Check(res)) {
+		if (!PyBytes_Check(res)) {
 			PyErr_Format(PyExc_TypeError,
 				     "__repr__ returned non-string (type %.200s)",
 				     Py_TYPE(res)->tp_name);
@@ -394,8 +394,8 @@ _PyObject_Str(PyObject *v)
 	PyObject *res;
 	int type_ok;
 	if (v == NULL)
-		return PyString_FromString("<NULL>");
-	if (PyString_CheckExact(v)) {
+		return PyBytes_FromString("<NULL>");
+	if (PyBytes_CheckExact(v)) {
 		Py_INCREF(v);
 		return v;
 	}
@@ -416,7 +416,7 @@ _PyObject_Str(PyObject *v)
 	Py_LeaveRecursiveCall();
 	if (res == NULL)
 		return NULL;
-	type_ok = PyString_Check(res);
+	type_ok = PyBytes_Check(res);
 #ifdef Py_USING_UNICODE
 	type_ok = type_ok || PyUnicode_Check(res);
 #endif
@@ -447,7 +447,7 @@ PyObject_Str(PyObject *v)
 		    	return NULL;
 	}
 #endif
-	assert(PyString_Check(res));
+	assert(PyBytes_Check(res));
 	return res;
 }
 
@@ -461,7 +461,7 @@ PyObject_Unicode(PyObject *v)
 	static PyObject *unicodestr;
 
 	if (v == NULL) {
-		res = PyString_FromString("<NULL>");
+		res = PyBytes_FromString("<NULL>");
 		if (res == NULL)
 			return NULL;
 		str = PyUnicode_FromEncodedObject(res, NULL, "strict");
@@ -475,7 +475,7 @@ PyObject_Unicode(PyObject *v)
 	   check this before trying the __unicode__
 	   method. */
 	if (unicodestr == NULL) {
-		unicodestr= PyString_InternFromString("__unicode__");
+		unicodestr= PyBytes_InternFromString("__unicode__");
 		if (unicodestr == NULL)
 			return NULL;
 	}
@@ -492,7 +492,7 @@ PyObject_Unicode(PyObject *v)
 			return PyUnicode_FromUnicode(PyUnicode_AS_UNICODE(v),
 			                             PyUnicode_GET_SIZE(v));
 		}
-		if (PyString_CheckExact(v)) {
+		if (PyBytes_CheckExact(v)) {
 			Py_INCREF(v);
 			res = v;
 		}
@@ -1084,7 +1084,7 @@ PyObject_GetAttrString(PyObject *v, const char *name)
 
 	if (Py_TYPE(v)->tp_getattr != NULL)
 		return (*Py_TYPE(v)->tp_getattr)(v, (char*)name);
-	w = PyString_InternFromString(name);
+	w = PyBytes_InternFromString(name);
 	if (w == NULL)
 		return NULL;
 	res = PyObject_GetAttr(v, w);
@@ -1112,7 +1112,7 @@ PyObject_SetAttrString(PyObject *v, const char *name, PyObject *w)
 
 	if (Py_TYPE(v)->tp_setattr != NULL)
 		return (*Py_TYPE(v)->tp_setattr)(v, (char*)name, w);
-	s = PyString_InternFromString(name);
+	s = PyBytes_InternFromString(name);
 	if (s == NULL)
 		return -1;
 	res = PyObject_SetAttr(v, s, w);
@@ -1125,7 +1125,7 @@ PyObject_GetAttr(PyObject *v, PyObject *name)
 {
 	PyTypeObject *tp = Py_TYPE(v);
 
-	if (!PyString_Check(name)) {
+	if (!PyBytes_Check(name)) {
 #ifdef Py_USING_UNICODE
 		/* The Unicode to string conversion is done here because the
 		   existing tp_getattro slots expect a string object as name
@@ -1147,10 +1147,10 @@ PyObject_GetAttr(PyObject *v, PyObject *name)
 	if (tp->tp_getattro != NULL)
 		return (*tp->tp_getattro)(v, name);
 	if (tp->tp_getattr != NULL)
-		return (*tp->tp_getattr)(v, PyString_AS_STRING(name));
+		return (*tp->tp_getattr)(v, PyBytes_AS_STRING(name));
 	PyErr_Format(PyExc_AttributeError,
 		     "'%.50s' object has no attribute '%.400s'",
-		     tp->tp_name, PyString_AS_STRING(name));
+		     tp->tp_name, PyBytes_AS_STRING(name));
 	return NULL;
 }
 
@@ -1172,7 +1172,7 @@ PyObject_SetAttr(PyObject *v, PyObject *name, PyObject *value)
 	PyTypeObject *tp = Py_TYPE(v);
 	int err;
 
-	if (!PyString_Check(name)){
+	if (!PyBytes_Check(name)){
 #ifdef Py_USING_UNICODE
 		/* The Unicode to string conversion is done here because the
 		   existing tp_setattro slots expect a string object as name
@@ -1194,14 +1194,14 @@ PyObject_SetAttr(PyObject *v, PyObject *name, PyObject *value)
 	else
 		Py_INCREF(name);
 
-	PyString_InternInPlace(&name);
+	PyBytes_InternInPlace(&name);
 	if (tp->tp_setattro != NULL) {
 		err = (*tp->tp_setattro)(v, name, value);
 		Py_DECREF(name);
 		return err;
 	}
 	if (tp->tp_setattr != NULL) {
-		err = (*tp->tp_setattr)(v, PyString_AS_STRING(name), value);
+		err = (*tp->tp_setattr)(v, PyBytes_AS_STRING(name), value);
 		Py_DECREF(name);
 		return err;
 	}
@@ -1212,14 +1212,14 @@ PyObject_SetAttr(PyObject *v, PyObject *name, PyObject *value)
 			     "(%s .%.100s)",
 			     tp->tp_name,
 			     value==NULL ? "del" : "assign to",
-			     PyString_AS_STRING(name));
+			     PyBytes_AS_STRING(name));
 	else
 		PyErr_Format(PyExc_TypeError,
 			     "'%.100s' object has only read-only attributes "
 			     "(%s .%.100s)",
 			     tp->tp_name,
 			     value==NULL ? "del" : "assign to",
-			     PyString_AS_STRING(name));
+			     PyBytes_AS_STRING(name));
 	return -1;
 }
 
@@ -1271,7 +1271,7 @@ PyObject_GenericGetAttr(PyObject *obj, PyObject *name)
 	Py_ssize_t dictoffset;
 	PyObject **dictptr;
 
-	if (!PyString_Check(name)){
+	if (!PyBytes_Check(name)){
 #ifdef Py_USING_UNICODE
 		/* The Unicode to string conversion is done here because the
 		   existing tp_setattro slots expect a string object as name
@@ -1386,7 +1386,7 @@ PyObject_GenericGetAttr(PyObject *obj, PyObject *name)
 
 	PyErr_Format(PyExc_AttributeError,
 		     "'%.50s' object has no attribute '%.400s'",
-		     tp->tp_name, PyString_AS_STRING(name));
+		     tp->tp_name, PyBytes_AS_STRING(name));
   done:
 	Py_DECREF(name);
 	return res;
@@ -1401,7 +1401,7 @@ PyObject_GenericSetAttr(PyObject *obj, PyObject *name, PyObject *value)
 	PyObject **dictptr;
 	int res = -1;
 
-	if (!PyString_Check(name)){
+	if (!PyBytes_Check(name)){
 #ifdef Py_USING_UNICODE
 		/* The Unicode to string conversion is done here because the
 		   existing tp_setattro slots expect a string object as name
@@ -1469,13 +1469,13 @@ PyObject_GenericSetAttr(PyObject *obj, PyObject *name, PyObject *value)
 	if (descr == NULL) {
 		PyErr_Format(PyExc_AttributeError,
 			     "'%.100s' object has no attribute '%.200s'",
-			     tp->tp_name, PyString_AS_STRING(name));
+			     tp->tp_name, PyBytes_AS_STRING(name));
 		goto done;
 	}
 
 	PyErr_Format(PyExc_AttributeError,
 		     "'%.50s' object attribute '%.400s' is read-only",
-		     tp->tp_name, PyString_AS_STRING(name));
+		     tp->tp_name, PyBytes_AS_STRING(name));
   done:
 	Py_DECREF(name);
 	return res;
@@ -1682,7 +1682,7 @@ merge_list_attr(PyObject* dict, PyObject* obj, const char *attrname)
 		int i;
 		for (i = 0; i < PyList_GET_SIZE(list); ++i) {
 			PyObject *item = PyList_GET_ITEM(list, i);
-			if (PyString_Check(item)) {
+			if (PyBytes_Check(item)) {
 				result = PyDict_SetItem(dict, item, Py_None);
 				if (result < 0)
 					break;
@@ -1904,7 +1904,7 @@ so there is exactly one (which is indestructible, by the way).
 static PyObject *
 none_repr(PyObject *op)
 {
-	return PyString_FromString("None");
+	return PyBytes_FromString("None");
 }
 
 /* ARGUSED */
@@ -1946,7 +1946,7 @@ PyObject _Py_NoneStruct = {
 static PyObject *
 NotImplemented_repr(PyObject *op)
 {
-	return PyString_FromString("NotImplemented");
+	return PyBytes_FromString("NotImplemented");
 }
 
 static PyTypeObject PyNotImplemented_Type = {
@@ -1983,7 +1983,7 @@ _Py_ReadyTypes(void)
 	if (PyType_Ready(&PyBool_Type) < 0)
 		Py_FatalError("Can't initialize 'bool'");
 
-	if (PyType_Ready(&PyString_Type) < 0)
+	if (PyType_Ready(&PyBytes_Type) < 0)
 		Py_FatalError("Can't initialize 'str'");
 
 	if (PyType_Ready(&PyByteArray_Type) < 0)
diff --git a/Objects/rangeobject.c b/Objects/rangeobject.c
index da4356b..b3ed673 100644
--- a/Objects/rangeobject.c
+++ b/Objects/rangeobject.c
@@ -113,16 +113,16 @@ range_repr(rangeobject *r)
 	PyObject *rtn;
 
 	if (r->start == 0 && r->step == 1)
-		rtn = PyString_FromFormat("xrange(%ld)",
+		rtn = PyBytes_FromFormat("xrange(%ld)",
 					  r->start + r->len * r->step);
 
 	else if (r->step == 1)
-		rtn = PyString_FromFormat("xrange(%ld, %ld)",
+		rtn = PyBytes_FromFormat("xrange(%ld, %ld)",
 					  r->start,
 					  r->start + r->len * r->step);
 
 	else
-		rtn = PyString_FromFormat("xrange(%ld, %ld, %ld)",
+		rtn = PyBytes_FromFormat("xrange(%ld, %ld, %ld)",
 					  r->start,
 					  r->start + r->len * r->step,
 					  r->step);
diff --git a/Objects/setobject.c b/Objects/setobject.c
index b379845..f63aa75 100644
--- a/Objects/setobject.c
+++ b/Objects/setobject.c
@@ -147,7 +147,7 @@ set_lookkey(PySetObject *so, PyObject *key, register long hash)
 
 /*
  * Hacked up version of set_lookkey which can assume keys are always strings;
- * This means we can always use _PyString_Eq directly and not have to check to
+ * This means we can always use _PyBytes_Eq directly and not have to check to
  * see if the comparison altered the table.
  */
 static setentry *
@@ -164,7 +164,7 @@ set_lookkey_string(PySetObject *so, PyObject *key, register long hash)
 	   including subclasses of str; e.g., one reason to subclass
 	   strings is to override __eq__, and for speed we don't cater to
 	   that here. */
-	if (!PyString_CheckExact(key)) {
+	if (!PyBytes_CheckExact(key)) {
 		so->lookup = set_lookkey;
 		return set_lookkey(so, key, hash);
 	}
@@ -175,7 +175,7 @@ set_lookkey_string(PySetObject *so, PyObject *key, register long hash)
 	if (entry->key == dummy)
 		freeslot = entry;
 	else {
-		if (entry->hash == hash && _PyString_Eq(entry->key, key))
+		if (entry->hash == hash && _PyBytes_Eq(entry->key, key))
 			return entry;
 		freeslot = NULL;
 	}
@@ -190,7 +190,7 @@ set_lookkey_string(PySetObject *so, PyObject *key, register long hash)
 		if (entry->key == key
 		    || (entry->hash == hash
 			&& entry->key != dummy
-			&& _PyString_Eq(entry->key, key)))
+			&& _PyBytes_Eq(entry->key, key)))
 			return entry;
 		if (entry->key == dummy && freeslot == NULL)
 			freeslot = entry;
@@ -377,8 +377,8 @@ set_add_key(register PySetObject *so, PyObject *key)
 	register long hash;
 	register Py_ssize_t n_used;
 
-	if (!PyString_CheckExact(key) ||
-	    (hash = ((PyStringObject *) key)->ob_shash) == -1) {
+	if (!PyBytes_CheckExact(key) ||
+	    (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
 		hash = PyObject_Hash(key);
 		if (hash == -1)
 			return -1;
@@ -424,8 +424,8 @@ set_discard_key(PySetObject *so, PyObject *key)
 	PyObject *old_key;
 
 	assert (PyAnySet_Check(so));
-	if (!PyString_CheckExact(key) ||
-	    (hash = ((PyStringObject *) key)->ob_shash) == -1) {
+	if (!PyBytes_CheckExact(key) ||
+	    (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
 		hash = PyObject_Hash(key);
 		if (hash == -1)
 			return -1;
@@ -614,7 +614,7 @@ set_repr(PySetObject *so)
 	if (status != 0) {
 		if (status < 0)
 			return NULL;
-		return PyString_FromFormat("%s(...)", so->ob_type->tp_name);
+		return PyBytes_FromFormat("%s(...)", so->ob_type->tp_name);
 	}
 
 	keys = PySequence_List((PyObject *)so);
@@ -625,8 +625,8 @@ set_repr(PySetObject *so)
 	if (listrepr == NULL)
 		goto done;
 
-	result = PyString_FromFormat("%s(%s)", so->ob_type->tp_name,
-		PyString_AS_STRING(listrepr));
+	result = PyBytes_FromFormat("%s(%s)", so->ob_type->tp_name,
+		PyBytes_AS_STRING(listrepr));
 	Py_DECREF(listrepr);
 done:
 	Py_ReprLeave((PyObject*)so);
@@ -681,8 +681,8 @@ set_contains_key(PySetObject *so, PyObject *key)
 	long hash;
 	setentry *entry;
 
-	if (!PyString_CheckExact(key) ||
-	    (hash = ((PyStringObject *) key)->ob_shash) == -1) {
+	if (!PyBytes_CheckExact(key) ||
+	    (hash = ((PyBytesObject *) key)->ob_shash) == -1) {
 		hash = PyObject_Hash(key);
 		if (hash == -1)
 			return -1;
@@ -979,7 +979,7 @@ make_new_set(PyTypeObject *type, PyObject *iterable)
 	register PySetObject *so = NULL;
 
 	if (dummy == NULL) { /* Auto-initialize dummy */
-		dummy = PyString_FromString("<dummy key>");
+		dummy = PyBytes_FromString("<dummy key>");
 		if (dummy == NULL)
 			return NULL;
 	}
@@ -2318,7 +2318,7 @@ test_c_api(PySetObject *so)
 	/* Exercise direct iteration */
 	i = 0, count = 0;
 	while (_PySet_Next((PyObject *)dup, &i, &x)) {
-		s = PyString_AsString(x);
+		s = PyBytes_AsString(x);
 		assert(s && (s[0] == 'a' || s[0] == 'b' || s[0] == 'c'));
 		count++;
 	}
diff --git a/Objects/sliceobject.c b/Objects/sliceobject.c
index 075418e..75048e3 100644
--- a/Objects/sliceobject.c
+++ b/Objects/sliceobject.c
@@ -19,7 +19,7 @@ this type and there is exactly one in existence.
 static PyObject *
 ellipsis_repr(PyObject *op)
 {
-	return PyString_FromString("Ellipsis");
+	return PyBytes_FromString("Ellipsis");
 }
 
 static PyTypeObject PyEllipsis_Type = {
@@ -228,14 +228,14 @@ slice_repr(PySliceObject *r)
 {
 	PyObject *s, *comma;
 
-	s = PyString_FromString("slice(");
-	comma = PyString_FromString(", ");
-	PyString_ConcatAndDel(&s, PyObject_Repr(r->start));
-	PyString_Concat(&s, comma);
-	PyString_ConcatAndDel(&s, PyObject_Repr(r->stop));
-	PyString_Concat(&s, comma);
-	PyString_ConcatAndDel(&s, PyObject_Repr(r->step));
-	PyString_ConcatAndDel(&s, PyString_FromString(")"));
+	s = PyBytes_FromString("slice(");
+	comma = PyBytes_FromString(", ");
+	PyBytes_ConcatAndDel(&s, PyObject_Repr(r->start));
+	PyBytes_Concat(&s, comma);
+	PyBytes_ConcatAndDel(&s, PyObject_Repr(r->stop));
+	PyBytes_Concat(&s, comma);
+	PyBytes_ConcatAndDel(&s, PyObject_Repr(r->step));
+	PyBytes_ConcatAndDel(&s, PyBytes_FromString(")"));
 	Py_DECREF(comma);
 	return s;
 }
diff --git a/Objects/stringlib/formatter.h b/Objects/stringlib/formatter.h
index 22dd292..05ccfea 100644
--- a/Objects/stringlib/formatter.h
+++ b/Objects/stringlib/formatter.h
@@ -778,7 +778,7 @@ FORMAT_STRING(PyObject* value, PyObject* args)
     /* This is to allow things like u''.format('') */
     if (!PyArg_ParseTuple(args, "O:__format__", &format_spec))
         goto done;
-    if (!(PyString_Check(format_spec) || PyUnicode_Check(format_spec))) {
+    if (!(PyBytes_Check(format_spec) || PyUnicode_Check(format_spec))) {
         PyErr_Format(PyExc_TypeError, "__format__ arg must be str "
 		     "or unicode, not %s", Py_TYPE(format_spec)->tp_name);
 	goto done;
diff --git a/Objects/stringlib/string_format.h b/Objects/stringlib/string_format.h
index be8e8080..2e9c7ef 100644
--- a/Objects/stringlib/string_format.h
+++ b/Objects/stringlib/string_format.h
@@ -496,7 +496,7 @@ render_field(PyObject *fieldobj, SubString *format_spec, OutputString *output)
 #if PY_VERSION_HEX >= 0x03000000
     assert(PyUnicode_Check(result));
 #else
-    assert(PyString_Check(result) || PyUnicode_Check(result));
+    assert(PyBytes_Check(result) || PyUnicode_Check(result));
 
     /* Convert result to our type.  We could be str, and result could
        be unicode */
diff --git a/Objects/stringlib/stringdefs.h b/Objects/stringlib/stringdefs.h
index daaa2e2..bdc3a29 100644
--- a/Objects/stringlib/stringdefs.h
+++ b/Objects/stringlib/stringdefs.h
@@ -6,7 +6,7 @@
    compiled as unicode. */
 #define STRINGLIB_IS_UNICODE     0
 
-#define STRINGLIB_OBJECT         PyStringObject
+#define STRINGLIB_OBJECT         PyBytesObject
 #define STRINGLIB_CHAR           char
 #define STRINGLIB_TYPE_NAME      "string"
 #define STRINGLIB_PARSE_CODE     "S"
@@ -16,13 +16,13 @@
 #define STRINGLIB_TOUPPER        toupper
 #define STRINGLIB_TOLOWER        tolower
 #define STRINGLIB_FILL           memset
-#define STRINGLIB_STR            PyString_AS_STRING
-#define STRINGLIB_LEN            PyString_GET_SIZE
-#define STRINGLIB_NEW            PyString_FromStringAndSize
-#define STRINGLIB_RESIZE         _PyString_Resize
-#define STRINGLIB_CHECK          PyString_Check
+#define STRINGLIB_STR            PyBytes_AS_STRING
+#define STRINGLIB_LEN            PyBytes_GET_SIZE
+#define STRINGLIB_NEW            PyBytes_FromStringAndSize
+#define STRINGLIB_RESIZE         _PyBytes_Resize
+#define STRINGLIB_CHECK          PyBytes_Check
 #define STRINGLIB_CMP            memcmp
 #define STRINGLIB_TOSTR          PyObject_Str
-#define STRINGLIB_GROUPING       _PyString_InsertThousandsGrouping
+#define STRINGLIB_GROUPING       _PyBytes_InsertThousandsGrouping
 
 #endif /* !STRINGLIB_STRINGDEFS_H */
diff --git a/Objects/stringobject.c b/Objects/stringobject.c
index ea1069d..0f4d4c3 100644
--- a/Objects/stringobject.c
+++ b/Objects/stringobject.c
@@ -12,8 +12,8 @@
 int null_strings, one_strings;
 #endif
 
-static PyStringObject *characters[UCHAR_MAX + 1];
-static PyStringObject *nullstring;
+static PyBytesObject *characters[UCHAR_MAX + 1];
+static PyBytesObject *nullstring;
 
 /* This dictionary holds all interned strings.  Note that references to
    strings in this dictionary are *not* counted in the string's ob_refcnt.
@@ -26,19 +26,19 @@ static PyStringObject *nullstring;
 static PyObject *interned;
 
 /*
-   For both PyString_FromString() and PyString_FromStringAndSize(), the
+   For both PyBytes_FromString() and PyBytes_FromStringAndSize(), the
    parameter `size' denotes number of characters to allocate, not counting any
    null terminating character.
 
-   For PyString_FromString(), the parameter `str' points to a null-terminated
+   For PyBytes_FromString(), the parameter `str' points to a null-terminated
    string containing exactly `size' bytes.
 
-   For PyString_FromStringAndSize(), the parameter the parameter `str' is
+   For PyBytes_FromStringAndSize(), the parameter the parameter `str' is
    either NULL or else points to a string containing at least `size' bytes.
-   For PyString_FromStringAndSize(), the string in the `str' parameter does
+   For PyBytes_FromStringAndSize(), the string in the `str' parameter does
    not have to be null-terminated.  (Therefore it is safe to construct a
-   substring by calling `PyString_FromStringAndSize(origstring, substrlen)'.)
-   If `str' is NULL then PyString_FromStringAndSize() will allocate `size+1'
+   substring by calling `PyBytes_FromStringAndSize(origstring, substrlen)'.)
+   If `str' is NULL then PyBytes_FromStringAndSize() will allocate `size+1'
    bytes (setting the last byte to the null terminating character) and you can
    fill in the data yourself.  If `str' is non-NULL then the resulting
    PyString object must be treated as immutable and you must not fill in nor
@@ -48,16 +48,16 @@ static PyObject *interned;
    items" in a variable-size object, will contain the number of bytes
    allocated for string data, not counting the null terminating character.  It
    is therefore equal to the equal to the `size' parameter (for
-   PyString_FromStringAndSize()) or the length of the string in the `str'
-   parameter (for PyString_FromString()).
+   PyBytes_FromStringAndSize()) or the length of the string in the `str'
+   parameter (for PyBytes_FromString()).
 */
 PyObject *
-PyString_FromStringAndSize(const char *str, Py_ssize_t size)
+PyBytes_FromStringAndSize(const char *str, Py_ssize_t size)
 {
-	register PyStringObject *op;
+	register PyBytesObject *op;
 	if (size < 0) {
 		PyErr_SetString(PyExc_SystemError,
-		    "Negative size passed to PyString_FromStringAndSize");
+		    "Negative size passed to PyBytes_FromStringAndSize");
 		return NULL;
 	}
 	if (size == 0 && (op = nullstring) != NULL) {
@@ -78,10 +78,10 @@ PyString_FromStringAndSize(const char *str, Py_ssize_t size)
 	}
 
 	/* Inline PyObject_NewVar */
-	op = (PyStringObject *)PyObject_MALLOC(sizeof(PyStringObject) + size);
+	op = (PyBytesObject *)PyObject_MALLOC(sizeof(PyBytesObject) + size);
 	if (op == NULL)
 		return PyErr_NoMemory();
-	PyObject_INIT_VAR(op, &PyString_Type, size);
+	PyObject_INIT_VAR(op, &PyBytes_Type, size);
 	op->ob_shash = -1;
 	op->ob_sstate = SSTATE_NOT_INTERNED;
 	if (str != NULL)
@@ -90,14 +90,14 @@ PyString_FromStringAndSize(const char *str, Py_ssize_t size)
 	/* share short strings */
 	if (size == 0) {
 		PyObject *t = (PyObject *)op;
-		PyString_InternInPlace(&t);
-		op = (PyStringObject *)t;
+		PyBytes_InternInPlace(&t);
+		op = (PyBytesObject *)t;
 		nullstring = op;
 		Py_INCREF(op);
 	} else if (size == 1 && str != NULL) {
 		PyObject *t = (PyObject *)op;
-		PyString_InternInPlace(&t);
-		op = (PyStringObject *)t;
+		PyBytes_InternInPlace(&t);
+		op = (PyBytesObject *)t;
 		characters[*str & UCHAR_MAX] = op;
 		Py_INCREF(op);
 	}
@@ -105,10 +105,10 @@ PyString_FromStringAndSize(const char *str, Py_ssize_t size)
 }
 
 PyObject *
-PyString_FromString(const char *str)
+PyBytes_FromString(const char *str)
 {
 	register size_t size;
-	register PyStringObject *op;
+	register PyBytesObject *op;
 
 	assert(str != NULL);
 	size = strlen(str);
@@ -133,24 +133,24 @@ PyString_FromString(const char *str)
 	}
 
 	/* Inline PyObject_NewVar */
-	op = (PyStringObject *)PyObject_MALLOC(sizeof(PyStringObject) + size);
+	op = (PyBytesObject *)PyObject_MALLOC(sizeof(PyBytesObject) + size);
 	if (op == NULL)
 		return PyErr_NoMemory();
-	PyObject_INIT_VAR(op, &PyString_Type, size);
+	PyObject_INIT_VAR(op, &PyBytes_Type, size);
 	op->ob_shash = -1;
 	op->ob_sstate = SSTATE_NOT_INTERNED;
 	Py_MEMCPY(op->ob_sval, str, size+1);
 	/* share short strings */
 	if (size == 0) {
 		PyObject *t = (PyObject *)op;
-		PyString_InternInPlace(&t);
-		op = (PyStringObject *)t;
+		PyBytes_InternInPlace(&t);
+		op = (PyBytesObject *)t;
 		nullstring = op;
 		Py_INCREF(op);
 	} else if (size == 1) {
 		PyObject *t = (PyObject *)op;
-		PyString_InternInPlace(&t);
-		op = (PyStringObject *)t;
+		PyBytes_InternInPlace(&t);
+		op = (PyBytesObject *)t;
 		characters[*str & UCHAR_MAX] = op;
 		Py_INCREF(op);
 	}
@@ -158,7 +158,7 @@ PyString_FromString(const char *str)
 }
 
 PyObject *
-PyString_FromFormatV(const char *format, va_list vargs)
+PyBytes_FromFormatV(const char *format, va_list vargs)
 {
 	va_list count;
 	Py_ssize_t n = 0;
@@ -233,11 +233,11 @@ PyString_FromFormatV(const char *format, va_list vargs)
 	/* step 2: fill the buffer */
 	/* Since we've analyzed how much space we need for the worst case,
 	   use sprintf directly instead of the slower PyOS_snprintf. */
-	string = PyString_FromStringAndSize(NULL, n);
+	string = PyBytes_FromStringAndSize(NULL, n);
 	if (!string)
 		return NULL;
 
-	s = PyString_AsString(string);
+	s = PyBytes_AsString(string);
 
 	for (f = format; *f; f++) {
 		if (*f == '%') {
@@ -337,12 +337,12 @@ PyString_FromFormatV(const char *format, va_list vargs)
 	}
 
  end:
-	_PyString_Resize(&string, s - PyString_AS_STRING(string));
+	_PyBytes_Resize(&string, s - PyBytes_AS_STRING(string));
 	return string;
 }
 
 PyObject *
-PyString_FromFormat(const char *format, ...)
+PyBytes_FromFormat(const char *format, ...)
 {
 	PyObject* ret;
 	va_list vargs;
@@ -352,34 +352,34 @@ PyString_FromFormat(const char *format, ...)
 #else
 	va_start(vargs);
 #endif
-	ret = PyString_FromFormatV(format, vargs);
+	ret = PyBytes_FromFormatV(format, vargs);
 	va_end(vargs);
 	return ret;
 }
 
 
-PyObject *PyString_Decode(const char *s,
+PyObject *PyBytes_Decode(const char *s,
 			  Py_ssize_t size,
 			  const char *encoding,
 			  const char *errors)
 {
     PyObject *v, *str;
 
-    str = PyString_FromStringAndSize(s, size);
+    str = PyBytes_FromStringAndSize(s, size);
     if (str == NULL)
 	return NULL;
-    v = PyString_AsDecodedString(str, encoding, errors);
+    v = PyBytes_AsDecodedString(str, encoding, errors);
     Py_DECREF(str);
     return v;
 }
 
-PyObject *PyString_AsDecodedObject(PyObject *str,
+PyObject *PyBytes_AsDecodedObject(PyObject *str,
 				   const char *encoding,
 				   const char *errors)
 {
     PyObject *v;
 
-    if (!PyString_Check(str)) {
+    if (!PyBytes_Check(str)) {
         PyErr_BadArgument();
         goto onError;
     }
@@ -404,13 +404,13 @@ PyObject *PyString_AsDecodedObject(PyObject *str,
     return NULL;
 }
 
-PyObject *PyString_AsDecodedString(PyObject *str,
+PyObject *PyBytes_AsDecodedString(PyObject *str,
 				   const char *encoding,
 				   const char *errors)
 {
     PyObject *v;
 
-    v = PyString_AsDecodedObject(str, encoding, errors);
+    v = PyBytes_AsDecodedObject(str, encoding, errors);
     if (v == NULL)
         goto onError;
 
@@ -424,7 +424,7 @@ PyObject *PyString_AsDecodedString(PyObject *str,
 	    goto onError;
     }
 #endif
-    if (!PyString_Check(v)) {
+    if (!PyBytes_Check(v)) {
         PyErr_Format(PyExc_TypeError,
                      "decoder did not return a string object (type=%.400s)",
                      Py_TYPE(v)->tp_name);
@@ -438,28 +438,28 @@ PyObject *PyString_AsDecodedString(PyObject *str,
     return NULL;
 }
 
-PyObject *PyString_Encode(const char *s,
+PyObject *PyBytes_Encode(const char *s,
 			  Py_ssize_t size,
 			  const char *encoding,
 			  const char *errors)
 {
     PyObject *v, *str;
 
-    str = PyString_FromStringAndSize(s, size);
+    str = PyBytes_FromStringAndSize(s, size);
     if (str == NULL)
 	return NULL;
-    v = PyString_AsEncodedString(str, encoding, errors);
+    v = PyBytes_AsEncodedString(str, encoding, errors);
     Py_DECREF(str);
     return v;
 }
 
-PyObject *PyString_AsEncodedObject(PyObject *str,
+PyObject *PyBytes_AsEncodedObject(PyObject *str,
 				   const char *encoding,
 				   const char *errors)
 {
     PyObject *v;
 
-    if (!PyString_Check(str)) {
+    if (!PyBytes_Check(str)) {
         PyErr_BadArgument();
         goto onError;
     }
@@ -484,13 +484,13 @@ PyObject *PyString_AsEncodedObject(PyObject *str,
     return NULL;
 }
 
-PyObject *PyString_AsEncodedString(PyObject *str,
+PyObject *PyBytes_AsEncodedString(PyObject *str,
 				   const char *encoding,
 				   const char *errors)
 {
     PyObject *v;
 
-    v = PyString_AsEncodedObject(str, encoding, errors);
+    v = PyBytes_AsEncodedObject(str, encoding, errors);
     if (v == NULL)
         goto onError;
 
@@ -504,7 +504,7 @@ PyObject *PyString_AsEncodedString(PyObject *str,
 	    goto onError;
     }
 #endif
-    if (!PyString_Check(v)) {
+    if (!PyBytes_Check(v)) {
         PyErr_Format(PyExc_TypeError,
                      "encoder did not return a string object (type=%.400s)",
                      Py_TYPE(v)->tp_name);
@@ -521,7 +521,7 @@ PyObject *PyString_AsEncodedString(PyObject *str,
 static void
 string_dealloc(PyObject *op)
 {
-	switch (PyString_CHECK_INTERNED(op)) {
+	switch (PyBytes_CHECK_INTERNED(op)) {
 		case SSTATE_NOT_INTERNED:
 			break;
 
@@ -547,7 +547,7 @@ string_dealloc(PyObject *op)
    the string is UTF-8 encoded and should be re-encoded in the
    specified encoding.  */
 
-PyObject *PyString_DecodeEscape(const char *s,
+PyObject *PyBytes_DecodeEscape(const char *s,
 				Py_ssize_t len,
 				const char *errors,
 				Py_ssize_t unicode,
@@ -558,10 +558,10 @@ PyObject *PyString_DecodeEscape(const char *s,
 	const char *end;
 	PyObject *v;
 	Py_ssize_t newlen = recode_encoding ? 4*len:len;
-	v = PyString_FromStringAndSize((char *)NULL, newlen);
+	v = PyBytes_FromStringAndSize((char *)NULL, newlen);
 	if (v == NULL)
 		return NULL;
-	p = buf = PyString_AsString(v);
+	p = buf = PyBytes_AsString(v);
 	end = s + len;
 	while (s < end) {
 		if (*s != '\\') {
@@ -585,9 +585,9 @@ PyObject *PyString_DecodeEscape(const char *s,
 				if (!w)	goto failed;
 
 				/* Append bytes to output buffer. */
-				assert(PyString_Check(w));
-				r = PyString_AS_STRING(w);
-				rn = PyString_GET_SIZE(w);
+				assert(PyBytes_Check(w));
+				r = PyBytes_AS_STRING(w);
+				rn = PyBytes_GET_SIZE(w);
 				Py_MEMCPY(p, r, rn);
 				p += rn;
 				Py_DECREF(w);
@@ -690,7 +690,7 @@ PyObject *PyString_DecodeEscape(const char *s,
 		}
 	}
 	if (p-buf < newlen)
-		_PyString_Resize(&v, p - buf);
+		_PyBytes_Resize(&v, p - buf);
 	return v;
   failed:
 	Py_DECREF(v);
@@ -705,7 +705,7 @@ string_getsize(register PyObject *op)
 {
     	char *s;
     	Py_ssize_t len;
-	if (PyString_AsStringAndSize(op, &s, &len))
+	if (PyBytes_AsStringAndSize(op, &s, &len))
 		return -1;
 	return len;
 }
@@ -715,29 +715,29 @@ string_getbuffer(register PyObject *op)
 {
     	char *s;
     	Py_ssize_t len;
-	if (PyString_AsStringAndSize(op, &s, &len))
+	if (PyBytes_AsStringAndSize(op, &s, &len))
 		return NULL;
 	return s;
 }
 
 Py_ssize_t
-PyString_Size(register PyObject *op)
+PyBytes_Size(register PyObject *op)
 {
-	if (!PyString_Check(op))
+	if (!PyBytes_Check(op))
 		return string_getsize(op);
 	return Py_SIZE(op);
 }
 
 /*const*/ char *
-PyString_AsString(register PyObject *op)
+PyBytes_AsString(register PyObject *op)
 {
-	if (!PyString_Check(op))
+	if (!PyBytes_Check(op))
 		return string_getbuffer(op);
-	return ((PyStringObject *)op) -> ob_sval;
+	return ((PyBytesObject *)op) -> ob_sval;
 }
 
 int
-PyString_AsStringAndSize(register PyObject *obj,
+PyBytes_AsStringAndSize(register PyObject *obj,
 			 register char **s,
 			 register Py_ssize_t *len)
 {
@@ -746,7 +746,7 @@ PyString_AsStringAndSize(register PyObject *obj,
 		return -1;
 	}
 
-	if (!PyString_Check(obj)) {
+	if (!PyBytes_Check(obj)) {
 #ifdef Py_USING_UNICODE
 		if (PyUnicode_Check(obj)) {
 			obj = _PyUnicode_AsDefaultEncodedString(obj, NULL);
@@ -763,10 +763,10 @@ PyString_AsStringAndSize(register PyObject *obj,
 		}
 	}
 
-	*s = PyString_AS_STRING(obj);
+	*s = PyBytes_AS_STRING(obj);
 	if (len != NULL)
-		*len = PyString_GET_SIZE(obj);
-	else if (strlen(*s) != (size_t)PyString_GET_SIZE(obj)) {
+		*len = PyBytes_GET_SIZE(obj);
+	else if (strlen(*s) != (size_t)PyBytes_GET_SIZE(obj)) {
 		PyErr_SetString(PyExc_TypeError,
 				"expected string without null bytes");
 		return -1;
@@ -784,23 +784,23 @@ PyString_AsStringAndSize(register PyObject *obj,
 #include "stringlib/find.h"
 #include "stringlib/partition.h"
 
-#define _Py_InsertThousandsGrouping _PyString_InsertThousandsGrouping
+#define _Py_InsertThousandsGrouping _PyBytes_InsertThousandsGrouping
 #include "stringlib/localeutil.h"
 
 
 
 static int
-string_print(PyStringObject *op, FILE *fp, int flags)
+string_print(PyBytesObject *op, FILE *fp, int flags)
 {
 	Py_ssize_t i, str_len;
 	char c;
 	int quote;
 
 	/* XXX Ought to check for interrupts when writing long strings */
-	if (! PyString_CheckExact(op)) {
+	if (! PyBytes_CheckExact(op)) {
 		int ret;
 		/* A str subclass may have its own __str__ method. */
-		op = (PyStringObject *) PyObject_Str((PyObject *)op);
+		op = (PyBytesObject *) PyObject_Str((PyObject *)op);
 		if (op == NULL)
 			return -1;
 		ret = string_print(op, fp, flags);
@@ -863,9 +863,9 @@ string_print(PyStringObject *op, FILE *fp, int flags)
 }
 
 PyObject *
-PyString_Repr(PyObject *obj, int smartquotes)
+PyBytes_Repr(PyObject *obj, int smartquotes)
 {
-	register PyStringObject* op = (PyStringObject*) obj;
+	register PyBytesObject* op = (PyBytesObject*) obj;
 	size_t newsize = 2 + 4 * Py_SIZE(op);
 	PyObject *v;
 	if (newsize > PY_SSIZE_T_MAX || newsize / 4 != Py_SIZE(op)) {
@@ -873,7 +873,7 @@ PyString_Repr(PyObject *obj, int smartquotes)
 			"string is too large to make repr");
                 return NULL;
 	}
-	v = PyString_FromStringAndSize((char *)NULL, newsize);
+	v = PyBytes_FromStringAndSize((char *)NULL, newsize);
 	if (v == NULL) {
 		return NULL;
 	}
@@ -890,12 +890,12 @@ PyString_Repr(PyObject *obj, int smartquotes)
 		    !memchr(op->ob_sval, '"', Py_SIZE(op)))
 			quote = '"';
 
-		p = PyString_AS_STRING(v);
+		p = PyBytes_AS_STRING(v);
 		*p++ = quote;
 		for (i = 0; i < Py_SIZE(op); i++) {
 			/* There's at least enough room for a hex escape
 			   and a closing quote. */
-			assert(newsize - (p - PyString_AS_STRING(v)) >= 5);
+			assert(newsize - (p - PyBytes_AS_STRING(v)) >= 5);
 			c = op->ob_sval[i];
 			if (c == quote || c == '\\')
 				*p++ = '\\', *p++ = c;
@@ -915,11 +915,11 @@ PyString_Repr(PyObject *obj, int smartquotes)
 			else
 				*p++ = c;
 		}
-		assert(newsize - (p - PyString_AS_STRING(v)) >= 1);
+		assert(newsize - (p - PyBytes_AS_STRING(v)) >= 1);
 		*p++ = quote;
 		*p = '\0';
-		_PyString_Resize(
-			&v, (p - PyString_AS_STRING(v)));
+		_PyBytes_Resize(
+			&v, (p - PyBytes_AS_STRING(v)));
 		return v;
 	}
 }
@@ -927,36 +927,36 @@ PyString_Repr(PyObject *obj, int smartquotes)
 static PyObject *
 string_repr(PyObject *op)
 {
-	return PyString_Repr(op, 1);
+	return PyBytes_Repr(op, 1);
 }
 
 static PyObject *
 string_str(PyObject *s)
 {
-	assert(PyString_Check(s));
-	if (PyString_CheckExact(s)) {
+	assert(PyBytes_Check(s));
+	if (PyBytes_CheckExact(s)) {
 		Py_INCREF(s);
 		return s;
 	}
 	else {
 		/* Subtype -- return genuine string with the same value. */
-		PyStringObject *t = (PyStringObject *) s;
-		return PyString_FromStringAndSize(t->ob_sval, Py_SIZE(t));
+		PyBytesObject *t = (PyBytesObject *) s;
+		return PyBytes_FromStringAndSize(t->ob_sval, Py_SIZE(t));
 	}
 }
 
 static Py_ssize_t
-string_length(PyStringObject *a)
+string_length(PyBytesObject *a)
 {
 	return Py_SIZE(a);
 }
 
 static PyObject *
-string_concat(register PyStringObject *a, register PyObject *bb)
+string_concat(register PyBytesObject *a, register PyObject *bb)
 {
 	register Py_ssize_t size;
-	register PyStringObject *op;
-	if (!PyString_Check(bb)) {
+	register PyBytesObject *op;
+	if (!PyBytes_Check(bb)) {
 #ifdef Py_USING_UNICODE
 		if (PyUnicode_Check(bb))
 		    return PyUnicode_Concat((PyObject *)a, bb);
@@ -968,10 +968,10 @@ string_concat(register PyStringObject *a, register PyObject *bb)
 			     Py_TYPE(bb)->tp_name);
 		return NULL;
 	}
-#define b ((PyStringObject *)bb)
+#define b ((PyBytesObject *)bb)
 	/* Optimize cases with empty left or right operand */
 	if ((Py_SIZE(a) == 0 || Py_SIZE(b) == 0) &&
-	    PyString_CheckExact(a) && PyString_CheckExact(b)) {
+	    PyBytes_CheckExact(a) && PyBytes_CheckExact(b)) {
 		if (Py_SIZE(a) == 0) {
 			Py_INCREF(bb);
 			return bb;
@@ -987,10 +987,10 @@ string_concat(register PyStringObject *a, register PyObject *bb)
 	}
 	  
 	/* Inline PyObject_NewVar */
-	op = (PyStringObject *)PyObject_MALLOC(sizeof(PyStringObject) + size);
+	op = (PyBytesObject *)PyObject_MALLOC(sizeof(PyBytesObject) + size);
 	if (op == NULL)
 		return PyErr_NoMemory();
-	PyObject_INIT_VAR(op, &PyString_Type, size);
+	PyObject_INIT_VAR(op, &PyBytes_Type, size);
 	op->ob_shash = -1;
 	op->ob_sstate = SSTATE_NOT_INTERNED;
 	Py_MEMCPY(op->ob_sval, a->ob_sval, Py_SIZE(a));
@@ -1001,12 +1001,12 @@ string_concat(register PyStringObject *a, register PyObject *bb)
 }
 
 static PyObject *
-string_repeat(register PyStringObject *a, register Py_ssize_t n)
+string_repeat(register PyBytesObject *a, register Py_ssize_t n)
 {
 	register Py_ssize_t i;
 	register Py_ssize_t j;
 	register Py_ssize_t size;
-	register PyStringObject *op;
+	register PyBytesObject *op;
 	size_t nbytes;
 	if (n < 0)
 		n = 0;
@@ -1019,21 +1019,21 @@ string_repeat(register PyStringObject *a, register Py_ssize_t n)
 			"repeated string is too long");
 		return NULL;
 	}
-	if (size == Py_SIZE(a) && PyString_CheckExact(a)) {
+	if (size == Py_SIZE(a) && PyBytes_CheckExact(a)) {
 		Py_INCREF(a);
 		return (PyObject *)a;
 	}
 	nbytes = (size_t)size;
-	if (nbytes + sizeof(PyStringObject) <= nbytes) {
+	if (nbytes + sizeof(PyBytesObject) <= nbytes) {
 		PyErr_SetString(PyExc_OverflowError,
 			"repeated string is too long");
 		return NULL;
 	}
-	op = (PyStringObject *)
-		PyObject_MALLOC(sizeof(PyStringObject) + nbytes);
+	op = (PyBytesObject *)
+		PyObject_MALLOC(sizeof(PyBytesObject) + nbytes);
 	if (op == NULL)
 		return PyErr_NoMemory();
-	PyObject_INIT_VAR(op, &PyString_Type, size);
+	PyObject_INIT_VAR(op, &PyBytes_Type, size);
 	op->ob_shash = -1;
 	op->ob_sstate = SSTATE_NOT_INTERNED;
 	op->ob_sval[size] = '\0';
@@ -1057,7 +1057,7 @@ string_repeat(register PyStringObject *a, register Py_ssize_t n)
 /* String slice a[i:j] consists of characters a[i] ... a[j-1] */
 
 static PyObject *
-string_slice(register PyStringObject *a, register Py_ssize_t i,
+string_slice(register PyBytesObject *a, register Py_ssize_t i,
 	     register Py_ssize_t j)
      /* j -- may be negative! */
 {
@@ -1067,25 +1067,25 @@ string_slice(register PyStringObject *a, register Py_ssize_t i,
 		j = 0; /* Avoid signed/unsigned bug in next line */
 	if (j > Py_SIZE(a))
 		j = Py_SIZE(a);
-	if (i == 0 && j == Py_SIZE(a) && PyString_CheckExact(a)) {
+	if (i == 0 && j == Py_SIZE(a) && PyBytes_CheckExact(a)) {
 		/* It's the same as a */
 		Py_INCREF(a);
 		return (PyObject *)a;
 	}
 	if (j < i)
 		j = i;
-	return PyString_FromStringAndSize(a->ob_sval + i, j-i);
+	return PyBytes_FromStringAndSize(a->ob_sval + i, j-i);
 }
 
 static int
 string_contains(PyObject *str_obj, PyObject *sub_obj)
 {
-	if (!PyString_CheckExact(sub_obj)) {
+	if (!PyBytes_CheckExact(sub_obj)) {
 #ifdef Py_USING_UNICODE
 		if (PyUnicode_Check(sub_obj))
 			return PyUnicode_Contains(str_obj, sub_obj);
 #endif
-		if (!PyString_Check(sub_obj)) {
+		if (!PyBytes_Check(sub_obj)) {
 			PyErr_Format(PyExc_TypeError,
 			    "'in <string>' requires string as left operand, "
 			    "not %.200s", Py_TYPE(sub_obj)->tp_name);
@@ -1097,7 +1097,7 @@ string_contains(PyObject *str_obj, PyObject *sub_obj)
 }
 
 static PyObject *
-string_item(PyStringObject *a, register Py_ssize_t i)
+string_item(PyBytesObject *a, register Py_ssize_t i)
 {
 	char pchar;
 	PyObject *v;
@@ -1108,7 +1108,7 @@ string_item(PyStringObject *a, register Py_ssize_t i)
 	pchar = a->ob_sval[i];
 	v = (PyObject *)characters[pchar & UCHAR_MAX];
 	if (v == NULL)
-		v = PyString_FromStringAndSize(&pchar, 1);
+		v = PyBytes_FromStringAndSize(&pchar, 1);
 	else {
 #ifdef COUNT_ALLOCS
 		one_strings++;
@@ -1119,7 +1119,7 @@ string_item(PyStringObject *a, register Py_ssize_t i)
 }
 
 static PyObject*
-string_richcompare(PyStringObject *a, PyStringObject *b, int op)
+string_richcompare(PyBytesObject *a, PyBytesObject *b, int op)
 {
 	int c;
 	Py_ssize_t len_a, len_b;
@@ -1127,7 +1127,7 @@ string_richcompare(PyStringObject *a, PyStringObject *b, int op)
 	PyObject *result;
 
 	/* Make sure both arguments are strings. */
-	if (!(PyString_Check(a) && PyString_Check(b))) {
+	if (!(PyBytes_Check(a) && PyBytes_Check(b))) {
 		result = Py_NotImplemented;
 		goto out;
 	}
@@ -1181,17 +1181,17 @@ string_richcompare(PyStringObject *a, PyStringObject *b, int op)
 }
 
 int
-_PyString_Eq(PyObject *o1, PyObject *o2)
+_PyBytes_Eq(PyObject *o1, PyObject *o2)
 {
-	PyStringObject *a = (PyStringObject*) o1;
-	PyStringObject *b = (PyStringObject*) o2;
+	PyBytesObject *a = (PyBytesObject*) o1;
+	PyBytesObject *b = (PyBytesObject*) o2;
         return Py_SIZE(a) == Py_SIZE(b)
           && *a->ob_sval == *b->ob_sval
           && memcmp(a->ob_sval, b->ob_sval, Py_SIZE(a)) == 0;
 }
 
 static long
-string_hash(PyStringObject *a)
+string_hash(PyBytesObject *a)
 {
 	register Py_ssize_t len;
 	register unsigned char *p;
@@ -1212,14 +1212,14 @@ string_hash(PyStringObject *a)
 }
 
 static PyObject*
-string_subscript(PyStringObject* self, PyObject* item)
+string_subscript(PyBytesObject* self, PyObject* item)
 {
 	if (PyIndex_Check(item)) {
 		Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
 		if (i == -1 && PyErr_Occurred())
 			return NULL;
 		if (i < 0)
-			i += PyString_GET_SIZE(self);
+			i += PyBytes_GET_SIZE(self);
 		return string_item(self, i);
 	}
 	else if (PySlice_Check(item)) {
@@ -1229,27 +1229,27 @@ string_subscript(PyStringObject* self, PyObject* item)
 		PyObject* result;
 
 		if (PySlice_GetIndicesEx((PySliceObject*)item,
-				 PyString_GET_SIZE(self),
+				 PyBytes_GET_SIZE(self),
 				 &start, &stop, &step, &slicelength) < 0) {
 			return NULL;
 		}
 
 		if (slicelength <= 0) {
-			return PyString_FromStringAndSize("", 0);
+			return PyBytes_FromStringAndSize("", 0);
 		}
 		else if (start == 0 && step == 1 &&
-			 slicelength == PyString_GET_SIZE(self) &&
-			 PyString_CheckExact(self)) {
+			 slicelength == PyBytes_GET_SIZE(self) &&
+			 PyBytes_CheckExact(self)) {
 			Py_INCREF(self);
 			return (PyObject *)self;
 		}
 		else if (step == 1) {
-			return PyString_FromStringAndSize(
-				PyString_AS_STRING(self) + start,
+			return PyBytes_FromStringAndSize(
+				PyBytes_AS_STRING(self) + start,
 				slicelength);
 		}
 		else {
-			source_buf = PyString_AsString((PyObject*)self);
+			source_buf = PyBytes_AsString((PyObject*)self);
 			result_buf = (char *)PyMem_Malloc(slicelength);
 			if (result_buf == NULL)
 				return PyErr_NoMemory();
@@ -1259,7 +1259,7 @@ string_subscript(PyStringObject* self, PyObject* item)
 				result_buf[i] = source_buf[cur];
 			}
 
-			result = PyString_FromStringAndSize(result_buf,
+			result = PyBytes_FromStringAndSize(result_buf,
 							    slicelength);
 			PyMem_Free(result_buf);
 			return result;
@@ -1274,7 +1274,7 @@ string_subscript(PyStringObject* self, PyObject* item)
 }
 
 static Py_ssize_t
-string_buffer_getreadbuf(PyStringObject *self, Py_ssize_t index, const void **ptr)
+string_buffer_getreadbuf(PyBytesObject *self, Py_ssize_t index, const void **ptr)
 {
 	if ( index != 0 ) {
 		PyErr_SetString(PyExc_SystemError,
@@ -1286,7 +1286,7 @@ string_buffer_getreadbuf(PyStringObject *self, Py_ssize_t index, const void **pt
 }
 
 static Py_ssize_t
-string_buffer_getwritebuf(PyStringObject *self, Py_ssize_t index, const void **ptr)
+string_buffer_getwritebuf(PyBytesObject *self, Py_ssize_t index, const void **ptr)
 {
 	PyErr_SetString(PyExc_TypeError,
 			"Cannot use string as modifiable buffer");
@@ -1294,7 +1294,7 @@ string_buffer_getwritebuf(PyStringObject *self, Py_ssize_t index, const void **p
 }
 
 static Py_ssize_t
-string_buffer_getsegcount(PyStringObject *self, Py_ssize_t *lenp)
+string_buffer_getsegcount(PyBytesObject *self, Py_ssize_t *lenp)
 {
 	if ( lenp )
 		*lenp = Py_SIZE(self);
@@ -1302,7 +1302,7 @@ string_buffer_getsegcount(PyStringObject *self, Py_ssize_t *lenp)
 }
 
 static Py_ssize_t
-string_buffer_getcharbuf(PyStringObject *self, Py_ssize_t index, const char **ptr)
+string_buffer_getcharbuf(PyBytesObject *self, Py_ssize_t index, const char **ptr)
 {
 	if ( index != 0 ) {
 		PyErr_SetString(PyExc_SystemError,
@@ -1314,7 +1314,7 @@ string_buffer_getcharbuf(PyStringObject *self, Py_ssize_t index, const char **pt
 }
 
 static int
-string_buffer_getbuffer(PyStringObject *self, Py_buffer *view, int flags)
+string_buffer_getbuffer(PyBytesObject *self, Py_buffer *view, int flags)
 {
 	return PyBuffer_FillInfo(view, (void *)self->ob_sval, Py_SIZE(self),
 				 0, flags);
@@ -1379,7 +1379,7 @@ static const char *stripformat[] = {"|O:lstrip", "|O:rstrip", "|O:strip"};
 	(maxsplit >= MAX_PREALLOC ? MAX_PREALLOC : maxsplit+1)
 
 #define SPLIT_APPEND(data, left, right)				\
-	str = PyString_FromStringAndSize((data) + (left),	\
+	str = PyBytes_FromStringAndSize((data) + (left),	\
 					 (right) - (left));	\
 	if (str == NULL)					\
 		goto onError;					\
@@ -1391,7 +1391,7 @@ static const char *stripformat[] = {"|O:lstrip", "|O:rstrip", "|O:strip"};
 		Py_DECREF(str);
 
 #define SPLIT_ADD(data, left, right) {				\
-	str = PyString_FromStringAndSize((data) + (left),	\
+	str = PyBytes_FromStringAndSize((data) + (left),	\
 					 (right) - (left));	\
 	if (str == NULL)					\
 		goto onError;					\
@@ -1416,9 +1416,9 @@ static const char *stripformat[] = {"|O:lstrip", "|O:rstrip", "|O:strip"};
 #define RSKIP_NONSPACE(s, i)     { while (i>=0  && !isspace(Py_CHARMASK(s[i]))) i--; }
 
 Py_LOCAL_INLINE(PyObject *)
-split_whitespace(PyStringObject *self, Py_ssize_t len, Py_ssize_t maxsplit)
+split_whitespace(PyBytesObject *self, Py_ssize_t len, Py_ssize_t maxsplit)
 {
-	const char *s = PyString_AS_STRING(self);
+	const char *s = PyBytes_AS_STRING(self);
 	Py_ssize_t i, j, count=0;
 	PyObject *str;
 	PyObject *list = PyList_New(PREALLOC_SIZE(maxsplit));
@@ -1433,7 +1433,7 @@ split_whitespace(PyStringObject *self, Py_ssize_t len, Py_ssize_t maxsplit)
 		if (i==len) break;
 		j = i; i++;
 		SKIP_NONSPACE(s, i, len);
-		if (j == 0 && i == len && PyString_CheckExact(self)) {
+		if (j == 0 && i == len && PyBytes_CheckExact(self)) {
 			/* No whitespace in self, so just use it as list[0] */
 			Py_INCREF(self);
 			PyList_SET_ITEM(list, 0, (PyObject *)self);
@@ -1458,9 +1458,9 @@ split_whitespace(PyStringObject *self, Py_ssize_t len, Py_ssize_t maxsplit)
 }
 
 Py_LOCAL_INLINE(PyObject *)
-split_char(PyStringObject *self, Py_ssize_t len, char ch, Py_ssize_t maxcount)
+split_char(PyBytesObject *self, Py_ssize_t len, char ch, Py_ssize_t maxcount)
 {
-	const char *s = PyString_AS_STRING(self);
+	const char *s = PyBytes_AS_STRING(self);
 	register Py_ssize_t i, j, count=0;
 	PyObject *str;
 	PyObject *list = PyList_New(PREALLOC_SIZE(maxcount));
@@ -1479,7 +1479,7 @@ split_char(PyStringObject *self, Py_ssize_t len, char ch, Py_ssize_t maxcount)
 			}
 		}
 	}
-	if (i == 0 && count == 0 && PyString_CheckExact(self)) {
+	if (i == 0 && count == 0 && PyBytes_CheckExact(self)) {
 		/* ch not in self, so just use self as list[0] */
 		Py_INCREF(self);
 		PyList_SET_ITEM(list, 0, (PyObject *)self);
@@ -1506,11 +1506,11 @@ whitespace string is a separator and empty strings are removed\n\
 from the result.");
 
 static PyObject *
-string_split(PyStringObject *self, PyObject *args)
+string_split(PyBytesObject *self, PyObject *args)
 {
-	Py_ssize_t len = PyString_GET_SIZE(self), n, i, j;
+	Py_ssize_t len = PyBytes_GET_SIZE(self), n, i, j;
 	Py_ssize_t maxsplit = -1, count=0;
-	const char *s = PyString_AS_STRING(self), *sub;
+	const char *s = PyBytes_AS_STRING(self), *sub;
 	PyObject *list, *str, *subobj = Py_None;
 #ifdef USE_FAST
 	Py_ssize_t pos;
@@ -1522,9 +1522,9 @@ string_split(PyStringObject *self, PyObject *args)
 		maxsplit = PY_SSIZE_T_MAX;
 	if (subobj == Py_None)
 		return split_whitespace(self, len, maxsplit);
-	if (PyString_Check(subobj)) {
-		sub = PyString_AS_STRING(subobj);
-		n = PyString_GET_SIZE(subobj);
+	if (PyBytes_Check(subobj)) {
+		sub = PyBytes_AS_STRING(subobj);
+		n = PyBytes_GET_SIZE(subobj);
 	}
 #ifdef Py_USING_UNICODE
 	else if (PyUnicode_Check(subobj))
@@ -1583,14 +1583,14 @@ the separator itself, and the part after it.  If the separator is not\n\
 found, returns S and two empty strings.");
 
 static PyObject *
-string_partition(PyStringObject *self, PyObject *sep_obj)
+string_partition(PyBytesObject *self, PyObject *sep_obj)
 {
 	const char *sep;
 	Py_ssize_t sep_len;
 
-	if (PyString_Check(sep_obj)) {
-		sep = PyString_AS_STRING(sep_obj);
-		sep_len = PyString_GET_SIZE(sep_obj);
+	if (PyBytes_Check(sep_obj)) {
+		sep = PyBytes_AS_STRING(sep_obj);
+		sep_len = PyBytes_GET_SIZE(sep_obj);
 	}
 #ifdef Py_USING_UNICODE
 	else if (PyUnicode_Check(sep_obj))
@@ -1601,7 +1601,7 @@ string_partition(PyStringObject *self, PyObject *sep_obj)
 
 	return stringlib_partition(
 		(PyObject*) self,
-		PyString_AS_STRING(self), PyString_GET_SIZE(self),
+		PyBytes_AS_STRING(self), PyBytes_GET_SIZE(self),
 		sep_obj, sep, sep_len
 		);
 }
@@ -1614,14 +1614,14 @@ the part before it, the separator itself, and the part after it.  If the\n\
 separator is not found, returns two empty strings and S.");
 
 static PyObject *
-string_rpartition(PyStringObject *self, PyObject *sep_obj)
+string_rpartition(PyBytesObject *self, PyObject *sep_obj)
 {
 	const char *sep;
 	Py_ssize_t sep_len;
 
-	if (PyString_Check(sep_obj)) {
-		sep = PyString_AS_STRING(sep_obj);
-		sep_len = PyString_GET_SIZE(sep_obj);
+	if (PyBytes_Check(sep_obj)) {
+		sep = PyBytes_AS_STRING(sep_obj);
+		sep_len = PyBytes_GET_SIZE(sep_obj);
 	}
 #ifdef Py_USING_UNICODE
 	else if (PyUnicode_Check(sep_obj))
@@ -1632,15 +1632,15 @@ string_rpartition(PyStringObject *self, PyObject *sep_obj)
 
 	return stringlib_rpartition(
 		(PyObject*) self,
-		PyString_AS_STRING(self), PyString_GET_SIZE(self),
+		PyBytes_AS_STRING(self), PyBytes_GET_SIZE(self),
 		sep_obj, sep, sep_len
 		);
 }
 
 Py_LOCAL_INLINE(PyObject *)
-rsplit_whitespace(PyStringObject *self, Py_ssize_t len, Py_ssize_t maxsplit)
+rsplit_whitespace(PyBytesObject *self, Py_ssize_t len, Py_ssize_t maxsplit)
 {
-	const char *s = PyString_AS_STRING(self);
+	const char *s = PyBytes_AS_STRING(self);
 	Py_ssize_t i, j, count=0;
 	PyObject *str;
 	PyObject *list = PyList_New(PREALLOC_SIZE(maxsplit));
@@ -1655,7 +1655,7 @@ rsplit_whitespace(PyStringObject *self, Py_ssize_t len, Py_ssize_t maxsplit)
 		if (i<0) break;
 		j = i; i--;
 		RSKIP_NONSPACE(s, i);
-		if (j == len-1 && i < 0 && PyString_CheckExact(self)) {
+		if (j == len-1 && i < 0 && PyBytes_CheckExact(self)) {
 			/* No whitespace in self, so just use it as list[0] */
 			Py_INCREF(self);
 			PyList_SET_ITEM(list, 0, (PyObject *)self);
@@ -1682,9 +1682,9 @@ rsplit_whitespace(PyStringObject *self, Py_ssize_t len, Py_ssize_t maxsplit)
 }
 
 Py_LOCAL_INLINE(PyObject *)
-rsplit_char(PyStringObject *self, Py_ssize_t len, char ch, Py_ssize_t maxcount)
+rsplit_char(PyBytesObject *self, Py_ssize_t len, char ch, Py_ssize_t maxcount)
 {
-	const char *s = PyString_AS_STRING(self);
+	const char *s = PyBytes_AS_STRING(self);
 	register Py_ssize_t i, j, count=0;
 	PyObject *str;
 	PyObject *list = PyList_New(PREALLOC_SIZE(maxcount));
@@ -1702,7 +1702,7 @@ rsplit_char(PyStringObject *self, Py_ssize_t len, char ch, Py_ssize_t maxcount)
 			}
 		}
 	}
-	if (i < 0 && count == 0 && PyString_CheckExact(self)) {
+	if (i < 0 && count == 0 && PyBytes_CheckExact(self)) {
 		/* ch not in self, so just use self as list[0] */
 		Py_INCREF(self);
 		PyList_SET_ITEM(list, 0, (PyObject *)self);
@@ -1731,9 +1731,9 @@ done. If sep is not specified or is None, any whitespace string\n\
 is a separator.");
 
 static PyObject *
-string_rsplit(PyStringObject *self, PyObject *args)
+string_rsplit(PyBytesObject *self, PyObject *args)
 {
-	Py_ssize_t len = PyString_GET_SIZE(self), n, i, j;
+	Py_ssize_t len = PyBytes_GET_SIZE(self), n, i, j;
 	Py_ssize_t maxsplit = -1, count=0;
 	const char *s, *sub;
 	PyObject *list, *str, *subobj = Py_None;
@@ -1744,9 +1744,9 @@ string_rsplit(PyStringObject *self, PyObject *args)
 		maxsplit = PY_SSIZE_T_MAX;
 	if (subobj == Py_None)
 		return rsplit_whitespace(self, len, maxsplit);
-	if (PyString_Check(subobj)) {
-		sub = PyString_AS_STRING(subobj);
-		n = PyString_GET_SIZE(subobj);
+	if (PyBytes_Check(subobj)) {
+		sub = PyBytes_AS_STRING(subobj);
+		n = PyBytes_GET_SIZE(subobj);
 	}
 #ifdef Py_USING_UNICODE
 	else if (PyUnicode_Check(subobj))
@@ -1769,7 +1769,7 @@ string_rsplit(PyStringObject *self, PyObject *args)
 	j = len;
 	i = j - n;
 
-	s = PyString_AS_STRING(self);
+	s = PyBytes_AS_STRING(self);
 	while ( (i >= 0) && (maxsplit-- > 0) ) {
 		for (; i>=0; i--) {
 			if (Py_STRING_MATCH(s, i, sub, n)) {
@@ -1799,10 +1799,10 @@ Return a string which is the concatenation of the strings in the\n\
 sequence.  The separator between elements is S.");
 
 static PyObject *
-string_join(PyStringObject *self, PyObject *orig)
+string_join(PyBytesObject *self, PyObject *orig)
 {
-	char *sep = PyString_AS_STRING(self);
-	const Py_ssize_t seplen = PyString_GET_SIZE(self);
+	char *sep = PyBytes_AS_STRING(self);
+	const Py_ssize_t seplen = PyBytes_GET_SIZE(self);
 	PyObject *res = NULL;
 	char *p;
 	Py_ssize_t seqlen = 0;
@@ -1818,11 +1818,11 @@ string_join(PyStringObject *self, PyObject *orig)
 	seqlen = PySequence_Size(seq);
 	if (seqlen == 0) {
 		Py_DECREF(seq);
-		return PyString_FromString("");
+		return PyBytes_FromString("");
 	}
 	if (seqlen == 1) {
 		item = PySequence_Fast_GET_ITEM(seq, 0);
-		if (PyString_CheckExact(item) || PyUnicode_CheckExact(item)) {
+		if (PyBytes_CheckExact(item) || PyUnicode_CheckExact(item)) {
 			Py_INCREF(item);
 			Py_DECREF(seq);
 			return item;
@@ -1838,7 +1838,7 @@ string_join(PyStringObject *self, PyObject *orig)
 	for (i = 0; i < seqlen; i++) {
 		const size_t old_sz = sz;
 		item = PySequence_Fast_GET_ITEM(seq, i);
-		if (!PyString_Check(item)){
+		if (!PyBytes_Check(item)){
 #ifdef Py_USING_UNICODE
 			if (PyUnicode_Check(item)) {
 				/* Defer to Unicode join.
@@ -1859,7 +1859,7 @@ string_join(PyStringObject *self, PyObject *orig)
 			Py_DECREF(seq);
 			return NULL;
 		}
-		sz += PyString_GET_SIZE(item);
+		sz += PyBytes_GET_SIZE(item);
 		if (i != 0)
 			sz += seplen;
 		if (sz < old_sz || sz > PY_SSIZE_T_MAX) {
@@ -1871,19 +1871,19 @@ string_join(PyStringObject *self, PyObject *orig)
 	}
 
 	/* Allocate result space. */
-	res = PyString_FromStringAndSize((char*)NULL, sz);
+	res = PyBytes_FromStringAndSize((char*)NULL, sz);
 	if (res == NULL) {
 		Py_DECREF(seq);
 		return NULL;
 	}
 
 	/* Catenate everything. */
-	p = PyString_AS_STRING(res);
+	p = PyBytes_AS_STRING(res);
 	for (i = 0; i < seqlen; ++i) {
 		size_t n;
 		item = PySequence_Fast_GET_ITEM(seq, i);
-		n = PyString_GET_SIZE(item);
-		Py_MEMCPY(p, PyString_AS_STRING(item), n);
+		n = PyBytes_GET_SIZE(item);
+		Py_MEMCPY(p, PyBytes_AS_STRING(item), n);
 		p += n;
 		if (i < seqlen - 1) {
 			Py_MEMCPY(p, sep, seplen);
@@ -1896,11 +1896,11 @@ string_join(PyStringObject *self, PyObject *orig)
 }
 
 PyObject *
-_PyString_Join(PyObject *sep, PyObject *x)
+_PyBytes_Join(PyObject *sep, PyObject *x)
 {
-	assert(sep != NULL && PyString_Check(sep));
+	assert(sep != NULL && PyBytes_Check(sep));
 	assert(x != NULL);
-	return string_join((PyStringObject *)sep, x);
+	return string_join((PyBytesObject *)sep, x);
 }
 
 Py_LOCAL_INLINE(void)
@@ -1919,7 +1919,7 @@ string_adjust_indices(Py_ssize_t *start, Py_ssize_t *end, Py_ssize_t len)
 }
 
 Py_LOCAL_INLINE(Py_ssize_t)
-string_find_internal(PyStringObject *self, PyObject *args, int dir)
+string_find_internal(PyBytesObject *self, PyObject *args, int dir)
 {
 	PyObject *subobj;
 	const char *sub;
@@ -1940,9 +1940,9 @@ string_find_internal(PyStringObject *self, PyObject *args, int dir)
 		if (!_PyEval_SliceIndex(obj_end, &end))
 	        return -2;
 
-	if (PyString_Check(subobj)) {
-		sub = PyString_AS_STRING(subobj);
-		sub_len = PyString_GET_SIZE(subobj);
+	if (PyBytes_Check(subobj)) {
+		sub = PyBytes_AS_STRING(subobj);
+		sub_len = PyBytes_GET_SIZE(subobj);
 	}
 #ifdef Py_USING_UNICODE
 	else if (PyUnicode_Check(subobj))
@@ -1956,11 +1956,11 @@ string_find_internal(PyStringObject *self, PyObject *args, int dir)
 
 	if (dir > 0)
 		return stringlib_find_slice(
-			PyString_AS_STRING(self), PyString_GET_SIZE(self),
+			PyBytes_AS_STRING(self), PyBytes_GET_SIZE(self),
 			sub, sub_len, start, end);
 	else
 		return stringlib_rfind_slice(
-			PyString_AS_STRING(self), PyString_GET_SIZE(self),
+			PyBytes_AS_STRING(self), PyBytes_GET_SIZE(self),
 			sub, sub_len, start, end);
 }
 
@@ -1975,7 +1975,7 @@ arguments start and end are interpreted as in slice notation.\n\
 Return -1 on failure.");
 
 static PyObject *
-string_find(PyStringObject *self, PyObject *args)
+string_find(PyBytesObject *self, PyObject *args)
 {
 	Py_ssize_t result = string_find_internal(self, args, +1);
 	if (result == -2)
@@ -1990,7 +1990,7 @@ PyDoc_STRVAR(index__doc__,
 Like S.find() but raise ValueError when the substring is not found.");
 
 static PyObject *
-string_index(PyStringObject *self, PyObject *args)
+string_index(PyBytesObject *self, PyObject *args)
 {
 	Py_ssize_t result = string_find_internal(self, args, +1);
 	if (result == -2)
@@ -2014,7 +2014,7 @@ arguments start and end are interpreted as in slice notation.\n\
 Return -1 on failure.");
 
 static PyObject *
-string_rfind(PyStringObject *self, PyObject *args)
+string_rfind(PyBytesObject *self, PyObject *args)
 {
 	Py_ssize_t result = string_find_internal(self, args, -1);
 	if (result == -2)
@@ -2029,7 +2029,7 @@ PyDoc_STRVAR(rindex__doc__,
 Like S.rfind() but raise ValueError when the substring is not found.");
 
 static PyObject *
-string_rindex(PyStringObject *self, PyObject *args)
+string_rindex(PyBytesObject *self, PyObject *args)
 {
 	Py_ssize_t result = string_find_internal(self, args, -1);
 	if (result == -2)
@@ -2044,12 +2044,12 @@ string_rindex(PyStringObject *self, PyObject *args)
 
 
 Py_LOCAL_INLINE(PyObject *)
-do_xstrip(PyStringObject *self, int striptype, PyObject *sepobj)
+do_xstrip(PyBytesObject *self, int striptype, PyObject *sepobj)
 {
-	char *s = PyString_AS_STRING(self);
-	Py_ssize_t len = PyString_GET_SIZE(self);
-	char *sep = PyString_AS_STRING(sepobj);
-	Py_ssize_t seplen = PyString_GET_SIZE(sepobj);
+	char *s = PyBytes_AS_STRING(self);
+	Py_ssize_t len = PyBytes_GET_SIZE(self);
+	char *sep = PyBytes_AS_STRING(sepobj);
+	Py_ssize_t seplen = PyBytes_GET_SIZE(sepobj);
 	Py_ssize_t i, j;
 
 	i = 0;
@@ -2067,20 +2067,20 @@ do_xstrip(PyStringObject *self, int striptype, PyObject *sepobj)
 		j++;
 	}
 
-	if (i == 0 && j == len && PyString_CheckExact(self)) {
+	if (i == 0 && j == len && PyBytes_CheckExact(self)) {
 		Py_INCREF(self);
 		return (PyObject*)self;
 	}
 	else
-		return PyString_FromStringAndSize(s+i, j-i);
+		return PyBytes_FromStringAndSize(s+i, j-i);
 }
 
 
 Py_LOCAL_INLINE(PyObject *)
-do_strip(PyStringObject *self, int striptype)
+do_strip(PyBytesObject *self, int striptype)
 {
-	char *s = PyString_AS_STRING(self);
-	Py_ssize_t len = PyString_GET_SIZE(self), i, j;
+	char *s = PyBytes_AS_STRING(self);
+	Py_ssize_t len = PyBytes_GET_SIZE(self), i, j;
 
 	i = 0;
 	if (striptype != RIGHTSTRIP) {
@@ -2097,17 +2097,17 @@ do_strip(PyStringObject *self, int striptype)
 		j++;
 	}
 
-	if (i == 0 && j == len && PyString_CheckExact(self)) {
+	if (i == 0 && j == len && PyBytes_CheckExact(self)) {
 		Py_INCREF(self);
 		return (PyObject*)self;
 	}
 	else
-		return PyString_FromStringAndSize(s+i, j-i);
+		return PyBytes_FromStringAndSize(s+i, j-i);
 }
 
 
 Py_LOCAL_INLINE(PyObject *)
-do_argstrip(PyStringObject *self, int striptype, PyObject *args)
+do_argstrip(PyBytesObject *self, int striptype, PyObject *args)
 {
 	PyObject *sep = NULL;
 
@@ -2115,7 +2115,7 @@ do_argstrip(PyStringObject *self, int striptype, PyObject *args)
 		return NULL;
 
 	if (sep != NULL && sep != Py_None) {
-		if (PyString_Check(sep))
+		if (PyBytes_Check(sep))
 			return do_xstrip(self, striptype, sep);
 #ifdef Py_USING_UNICODE
 		else if (PyUnicode_Check(sep)) {
@@ -2152,7 +2152,7 @@ If chars is given and not None, remove characters in chars instead.\n\
 If chars is unicode, S will be converted to unicode before stripping");
 
 static PyObject *
-string_strip(PyStringObject *self, PyObject *args)
+string_strip(PyBytesObject *self, PyObject *args)
 {
 	if (PyTuple_GET_SIZE(args) == 0)
 		return do_strip(self, BOTHSTRIP); /* Common case */
@@ -2169,7 +2169,7 @@ If chars is given and not None, remove characters in chars instead.\n\
 If chars is unicode, S will be converted to unicode before stripping");
 
 static PyObject *
-string_lstrip(PyStringObject *self, PyObject *args)
+string_lstrip(PyBytesObject *self, PyObject *args)
 {
 	if (PyTuple_GET_SIZE(args) == 0)
 		return do_strip(self, LEFTSTRIP); /* Common case */
@@ -2186,7 +2186,7 @@ If chars is given and not None, remove characters in chars instead.\n\
 If chars is unicode, S will be converted to unicode before stripping");
 
 static PyObject *
-string_rstrip(PyStringObject *self, PyObject *args)
+string_rstrip(PyBytesObject *self, PyObject *args)
 {
 	if (PyTuple_GET_SIZE(args) == 0)
 		return do_strip(self, RIGHTSTRIP); /* Common case */
@@ -2206,19 +2206,19 @@ Return a copy of the string S converted to lowercase.");
 #endif
 
 static PyObject *
-string_lower(PyStringObject *self)
+string_lower(PyBytesObject *self)
 {
 	char *s;
-	Py_ssize_t i, n = PyString_GET_SIZE(self);
+	Py_ssize_t i, n = PyBytes_GET_SIZE(self);
 	PyObject *newobj;
 
-	newobj = PyString_FromStringAndSize(NULL, n);
+	newobj = PyBytes_FromStringAndSize(NULL, n);
 	if (!newobj)
 		return NULL;
 
-	s = PyString_AS_STRING(newobj);
+	s = PyBytes_AS_STRING(newobj);
 
-	Py_MEMCPY(s, PyString_AS_STRING(self), n);
+	Py_MEMCPY(s, PyBytes_AS_STRING(self), n);
 
 	for (i = 0; i < n; i++) {
 		int c = Py_CHARMASK(s[i]);
@@ -2239,19 +2239,19 @@ Return a copy of the string S converted to uppercase.");
 #endif
 
 static PyObject *
-string_upper(PyStringObject *self)
+string_upper(PyBytesObject *self)
 {
 	char *s;
-	Py_ssize_t i, n = PyString_GET_SIZE(self);
+	Py_ssize_t i, n = PyBytes_GET_SIZE(self);
 	PyObject *newobj;
 
-	newobj = PyString_FromStringAndSize(NULL, n);
+	newobj = PyBytes_FromStringAndSize(NULL, n);
 	if (!newobj)
 		return NULL;
 
-	s = PyString_AS_STRING(newobj);
+	s = PyBytes_AS_STRING(newobj);
 
-	Py_MEMCPY(s, PyString_AS_STRING(self), n);
+	Py_MEMCPY(s, PyBytes_AS_STRING(self), n);
 
 	for (i = 0; i < n; i++) {
 		int c = Py_CHARMASK(s[i]);
@@ -2269,17 +2269,17 @@ Return a titlecased version of S, i.e. words start with uppercase\n\
 characters, all remaining cased characters have lowercase.");
 
 static PyObject*
-string_title(PyStringObject *self)
+string_title(PyBytesObject *self)
 {
-	char *s = PyString_AS_STRING(self), *s_new;
-	Py_ssize_t i, n = PyString_GET_SIZE(self);
+	char *s = PyBytes_AS_STRING(self), *s_new;
+	Py_ssize_t i, n = PyBytes_GET_SIZE(self);
 	int previous_is_cased = 0;
 	PyObject *newobj;
 
-	newobj = PyString_FromStringAndSize(NULL, n);
+	newobj = PyBytes_FromStringAndSize(NULL, n);
 	if (newobj == NULL)
 		return NULL;
-	s_new = PyString_AsString(newobj);
+	s_new = PyBytes_AsString(newobj);
 	for (i = 0; i < n; i++) {
 		int c = Py_CHARMASK(*s++);
 		if (islower(c)) {
@@ -2304,16 +2304,16 @@ Return a copy of the string S with only its first character\n\
 capitalized.");
 
 static PyObject *
-string_capitalize(PyStringObject *self)
+string_capitalize(PyBytesObject *self)
 {
-	char *s = PyString_AS_STRING(self), *s_new;
-	Py_ssize_t i, n = PyString_GET_SIZE(self);
+	char *s = PyBytes_AS_STRING(self), *s_new;
+	Py_ssize_t i, n = PyBytes_GET_SIZE(self);
 	PyObject *newobj;
 
-	newobj = PyString_FromStringAndSize(NULL, n);
+	newobj = PyBytes_FromStringAndSize(NULL, n);
 	if (newobj == NULL)
 		return NULL;
-	s_new = PyString_AsString(newobj);
+	s_new = PyBytes_AsString(newobj);
 	if (0 < n) {
 		int c = Py_CHARMASK(*s++);
 		if (islower(c))
@@ -2342,10 +2342,10 @@ string S[start:end].  Optional arguments start and end are interpreted\n\
 as in slice notation.");
 
 static PyObject *
-string_count(PyStringObject *self, PyObject *args)
+string_count(PyBytesObject *self, PyObject *args)
 {
 	PyObject *sub_obj;
-	const char *str = PyString_AS_STRING(self), *sub;
+	const char *str = PyBytes_AS_STRING(self), *sub;
 	Py_ssize_t sub_len;
 	Py_ssize_t start = 0, end = PY_SSIZE_T_MAX;
 
@@ -2353,9 +2353,9 @@ string_count(PyStringObject *self, PyObject *args)
 		_PyEval_SliceIndex, &start, _PyEval_SliceIndex, &end))
 		return NULL;
 
-	if (PyString_Check(sub_obj)) {
-		sub = PyString_AS_STRING(sub_obj);
-		sub_len = PyString_GET_SIZE(sub_obj);
+	if (PyBytes_Check(sub_obj)) {
+		sub = PyBytes_AS_STRING(sub_obj);
+		sub_len = PyBytes_GET_SIZE(sub_obj);
 	}
 #ifdef Py_USING_UNICODE
 	else if (PyUnicode_Check(sub_obj)) {
@@ -2370,7 +2370,7 @@ string_count(PyStringObject *self, PyObject *args)
 	else if (PyObject_AsCharBuffer(sub_obj, &sub, &sub_len))
 		return NULL;
 
-	string_adjust_indices(&start, &end, PyString_GET_SIZE(self));
+	string_adjust_indices(&start, &end, PyBytes_GET_SIZE(self));
 
 	return PyInt_FromSsize_t(
 		stringlib_count(str + start, end - start, sub, sub_len)
@@ -2384,16 +2384,16 @@ Return a copy of the string S with uppercase characters\n\
 converted to lowercase and vice versa.");
 
 static PyObject *
-string_swapcase(PyStringObject *self)
+string_swapcase(PyBytesObject *self)
 {
-	char *s = PyString_AS_STRING(self), *s_new;
-	Py_ssize_t i, n = PyString_GET_SIZE(self);
+	char *s = PyBytes_AS_STRING(self), *s_new;
+	Py_ssize_t i, n = PyBytes_GET_SIZE(self);
 	PyObject *newobj;
 
-	newobj = PyString_FromStringAndSize(NULL, n);
+	newobj = PyBytes_FromStringAndSize(NULL, n);
 	if (newobj == NULL)
 		return NULL;
-	s_new = PyString_AsString(newobj);
+	s_new = PyBytes_AsString(newobj);
 	for (i = 0; i < n; i++) {
 		int c = Py_CHARMASK(*s++);
 		if (islower(c)) {
@@ -2419,7 +2419,7 @@ remaining characters have been mapped through the given\n\
 translation table, which must be a string of length 256.");
 
 static PyObject *
-string_translate(PyStringObject *self, PyObject *args)
+string_translate(PyBytesObject *self, PyObject *args)
 {
 	register char *input, *output;
 	const char *table;
@@ -2435,9 +2435,9 @@ string_translate(PyStringObject *self, PyObject *args)
 			      &tableobj, &delobj))
 		return NULL;
 
-	if (PyString_Check(tableobj)) {
-		table = PyString_AS_STRING(tableobj);
-		tablen = PyString_GET_SIZE(tableobj);
+	if (PyBytes_Check(tableobj)) {
+		table = PyBytes_AS_STRING(tableobj);
+		tablen = PyBytes_GET_SIZE(tableobj);
 	}
 	else if (tableobj == Py_None) {
 		table = NULL;
@@ -2466,9 +2466,9 @@ string_translate(PyStringObject *self, PyObject *args)
 	}
 
 	if (delobj != NULL) {
-		if (PyString_Check(delobj)) {
-			del_table = PyString_AS_STRING(delobj);
-			dellen = PyString_GET_SIZE(delobj);
+		if (PyBytes_Check(delobj)) {
+			del_table = PyBytes_AS_STRING(delobj);
+			dellen = PyBytes_GET_SIZE(delobj);
 		}
 #ifdef Py_USING_UNICODE
 		else if (PyUnicode_Check(delobj)) {
@@ -2485,12 +2485,12 @@ string_translate(PyStringObject *self, PyObject *args)
 		dellen = 0;
 	}
 
-	inlen = PyString_GET_SIZE(input_obj);
-	result = PyString_FromStringAndSize((char *)NULL, inlen);
+	inlen = PyBytes_GET_SIZE(input_obj);
+	result = PyBytes_FromStringAndSize((char *)NULL, inlen);
 	if (result == NULL)
 		return NULL;
-	output_start = output = PyString_AsString(result);
-	input = PyString_AS_STRING(input_obj);
+	output_start = output = PyBytes_AsString(result);
+	input = PyBytes_AS_STRING(input_obj);
 
 	if (dellen == 0 && table != NULL) {
 		/* If no deletions are required, use faster code */
@@ -2499,7 +2499,7 @@ string_translate(PyStringObject *self, PyObject *args)
 			if (Py_CHARMASK((*output++ = table[c])) != c)
 				changed = 1;
 		}
-		if (changed || !PyString_CheckExact(input_obj))
+		if (changed || !PyBytes_CheckExact(input_obj))
 			return result;
 		Py_DECREF(result);
 		Py_INCREF(input_obj);
@@ -2524,14 +2524,14 @@ string_translate(PyStringObject *self, PyObject *args)
 				continue;
 		changed = 1;
 	}
-	if (!changed && PyString_CheckExact(input_obj)) {
+	if (!changed && PyBytes_CheckExact(input_obj)) {
 		Py_DECREF(result);
 		Py_INCREF(input_obj);
 		return input_obj;
 	}
 	/* Fix the size of the resulting string */
 	if (inlen > 0)
-		_PyString_Resize(&result, output - output_start);
+		_PyBytes_Resize(&result, output - output_start);
 	return result;
 }
 
@@ -2546,16 +2546,16 @@ string_translate(PyStringObject *self, PyObject *args)
 
 /* String ops must return a string.  */
 /* If the object is subclass of string, create a copy */
-Py_LOCAL(PyStringObject *)
-return_self(PyStringObject *self)
+Py_LOCAL(PyBytesObject *)
+return_self(PyBytesObject *self)
 {
-	if (PyString_CheckExact(self)) {
+	if (PyBytes_CheckExact(self)) {
 		Py_INCREF(self);
 		return self;
 	}
-	return (PyStringObject *)PyString_FromStringAndSize(
-		PyString_AS_STRING(self),
-		PyString_GET_SIZE(self));
+	return (PyBytesObject *)PyBytes_FromStringAndSize(
+		PyBytes_AS_STRING(self),
+		PyBytes_GET_SIZE(self));
 }
 
 Py_LOCAL_INLINE(Py_ssize_t)
@@ -2665,17 +2665,17 @@ countstring(const char *target, Py_ssize_t target_len,
 /* Algorithms for different cases of string replacement */
 
 /* len(self)>=1, from="", len(to)>=1, maxcount>=1 */
-Py_LOCAL(PyStringObject *)
-replace_interleave(PyStringObject *self,
+Py_LOCAL(PyBytesObject *)
+replace_interleave(PyBytesObject *self,
 		   const char *to_s, Py_ssize_t to_len,
 		   Py_ssize_t maxcount)
 {
 	char *self_s, *result_s;
 	Py_ssize_t self_len, result_len;
 	Py_ssize_t count, i, product;
-	PyStringObject *result;
+	PyBytesObject *result;
 
-	self_len = PyString_GET_SIZE(self);
+	self_len = PyBytes_GET_SIZE(self);
 
 	/* 1 at the end plus 1 after every character */
 	count = self_len+1;
@@ -2697,12 +2697,12 @@ replace_interleave(PyStringObject *self,
 		return NULL;
 	}
   
-	if (! (result = (PyStringObject *)
-	                 PyString_FromStringAndSize(NULL, result_len)) )
+	if (! (result = (PyBytesObject *)
+	                 PyBytes_FromStringAndSize(NULL, result_len)) )
 		return NULL;
 
-	self_s = PyString_AS_STRING(self);
-	result_s = PyString_AS_STRING(result);
+	self_s = PyBytes_AS_STRING(self);
+	result_s = PyBytes_AS_STRING(result);
 
 	/* TODO: special case single character, which doesn't need memcpy */
 
@@ -2725,18 +2725,18 @@ replace_interleave(PyStringObject *self,
 
 /* Special case for deleting a single character */
 /* len(self)>=1, len(from)==1, to="", maxcount>=1 */
-Py_LOCAL(PyStringObject *)
-replace_delete_single_character(PyStringObject *self,
+Py_LOCAL(PyBytesObject *)
+replace_delete_single_character(PyBytesObject *self,
 				char from_c, Py_ssize_t maxcount)
 {
 	char *self_s, *result_s;
 	char *start, *next, *end;
 	Py_ssize_t self_len, result_len;
 	Py_ssize_t count;
-	PyStringObject *result;
+	PyBytesObject *result;
 
-	self_len = PyString_GET_SIZE(self);
-	self_s = PyString_AS_STRING(self);
+	self_len = PyBytes_GET_SIZE(self);
+	self_s = PyBytes_AS_STRING(self);
 
 	count = countchar(self_s, self_len, from_c, maxcount);
 	if (count == 0) {
@@ -2746,10 +2746,10 @@ replace_delete_single_character(PyStringObject *self,
 	result_len = self_len - count;  /* from_len == 1 */
 	assert(result_len>=0);
 
-	if ( (result = (PyStringObject *)
-	                PyString_FromStringAndSize(NULL, result_len)) == NULL)
+	if ( (result = (PyBytesObject *)
+	                PyBytes_FromStringAndSize(NULL, result_len)) == NULL)
 		return NULL;
-	result_s = PyString_AS_STRING(result);
+	result_s = PyBytes_AS_STRING(result);
 
 	start = self_s;
 	end = self_s + self_len;
@@ -2768,18 +2768,18 @@ replace_delete_single_character(PyStringObject *self,
 
 /* len(self)>=1, len(from)>=2, to="", maxcount>=1 */
 
-Py_LOCAL(PyStringObject *)
-replace_delete_substring(PyStringObject *self,
+Py_LOCAL(PyBytesObject *)
+replace_delete_substring(PyBytesObject *self,
 			 const char *from_s, Py_ssize_t from_len,
 			 Py_ssize_t maxcount) {
 	char *self_s, *result_s;
 	char *start, *next, *end;
 	Py_ssize_t self_len, result_len;
 	Py_ssize_t count, offset;
-	PyStringObject *result;
+	PyBytesObject *result;
 
-	self_len = PyString_GET_SIZE(self);
-	self_s = PyString_AS_STRING(self);
+	self_len = PyBytes_GET_SIZE(self);
+	self_s = PyBytes_AS_STRING(self);
 
 	count = countstring(self_s, self_len,
 			    from_s, from_len,
@@ -2794,11 +2794,11 @@ replace_delete_substring(PyStringObject *self,
 	result_len = self_len - (count * from_len);
 	assert (result_len>=0);
 
-	if ( (result = (PyStringObject *)
-	      PyString_FromStringAndSize(NULL, result_len)) == NULL )
+	if ( (result = (PyBytesObject *)
+	      PyBytes_FromStringAndSize(NULL, result_len)) == NULL )
 		return NULL;
 
-	result_s = PyString_AS_STRING(result);
+	result_s = PyBytes_AS_STRING(result);
 
 	start = self_s;
 	end = self_s + self_len;
@@ -2820,18 +2820,18 @@ replace_delete_substring(PyStringObject *self,
 }
 
 /* len(self)>=1, len(from)==len(to)==1, maxcount>=1 */
-Py_LOCAL(PyStringObject *)
-replace_single_character_in_place(PyStringObject *self,
+Py_LOCAL(PyBytesObject *)
+replace_single_character_in_place(PyBytesObject *self,
 				  char from_c, char to_c,
 				  Py_ssize_t maxcount)
 {
 	char *self_s, *result_s, *start, *end, *next;
 	Py_ssize_t self_len;
-	PyStringObject *result;
+	PyBytesObject *result;
 
 	/* The result string will be the same size */
-	self_s = PyString_AS_STRING(self);
-	self_len = PyString_GET_SIZE(self);
+	self_s = PyBytes_AS_STRING(self);
+	self_len = PyBytes_GET_SIZE(self);
 
 	next = findchar(self_s, self_len, from_c);
 
@@ -2841,10 +2841,10 @@ replace_single_character_in_place(PyStringObject *self,
 	}
 
 	/* Need to make a new string */
-	result = (PyStringObject *) PyString_FromStringAndSize(NULL, self_len);
+	result = (PyBytesObject *) PyBytes_FromStringAndSize(NULL, self_len);
 	if (result == NULL)
 		return NULL;
-	result_s = PyString_AS_STRING(result);
+	result_s = PyBytes_AS_STRING(result);
 	Py_MEMCPY(result_s, self_s, self_len);
 
 	/* change everything in-place, starting with this one */
@@ -2865,8 +2865,8 @@ replace_single_character_in_place(PyStringObject *self,
 }
 
 /* len(self)>=1, len(from)==len(to)>=2, maxcount>=1 */
-Py_LOCAL(PyStringObject *)
-replace_substring_in_place(PyStringObject *self,
+Py_LOCAL(PyBytesObject *)
+replace_substring_in_place(PyBytesObject *self,
 			   const char *from_s, Py_ssize_t from_len,
 			   const char *to_s, Py_ssize_t to_len,
 			   Py_ssize_t maxcount)
@@ -2874,12 +2874,12 @@ replace_substring_in_place(PyStringObject *self,
 	char *result_s, *start, *end;
 	char *self_s;
 	Py_ssize_t self_len, offset;
-	PyStringObject *result;
+	PyBytesObject *result;
 
 	/* The result string will be the same size */
 
-	self_s = PyString_AS_STRING(self);
-	self_len = PyString_GET_SIZE(self);
+	self_s = PyBytes_AS_STRING(self);
+	self_len = PyBytes_GET_SIZE(self);
 
 	offset = findstring(self_s, self_len,
 			    from_s, from_len,
@@ -2890,10 +2890,10 @@ replace_substring_in_place(PyStringObject *self,
 	}
 
 	/* Need to make a new string */
-	result = (PyStringObject *) PyString_FromStringAndSize(NULL, self_len);
+	result = (PyBytesObject *) PyBytes_FromStringAndSize(NULL, self_len);
 	if (result == NULL)
 		return NULL;
-	result_s = PyString_AS_STRING(result);
+	result_s = PyBytes_AS_STRING(result);
 	Py_MEMCPY(result_s, self_s, self_len);
 
 	/* change everything in-place, starting with this one */
@@ -2916,8 +2916,8 @@ replace_substring_in_place(PyStringObject *self,
 }
 
 /* len(self)>=1, len(from)==1, len(to)>=2, maxcount>=1 */
-Py_LOCAL(PyStringObject *)
-replace_single_character(PyStringObject *self,
+Py_LOCAL(PyBytesObject *)
+replace_single_character(PyBytesObject *self,
 			 char from_c,
 			 const char *to_s, Py_ssize_t to_len,
 			 Py_ssize_t maxcount)
@@ -2926,10 +2926,10 @@ replace_single_character(PyStringObject *self,
 	char *start, *next, *end;
 	Py_ssize_t self_len, result_len;
 	Py_ssize_t count, product;
-	PyStringObject *result;
+	PyBytesObject *result;
 
-	self_s = PyString_AS_STRING(self);
-	self_len = PyString_GET_SIZE(self);
+	self_s = PyBytes_AS_STRING(self);
+	self_len = PyBytes_GET_SIZE(self);
 
 	count = countchar(self_s, self_len, from_c, maxcount);
 	if (count == 0) {
@@ -2950,10 +2950,10 @@ replace_single_character(PyStringObject *self,
 		return NULL;
 	}
 
-	if ( (result = (PyStringObject *)
-	      PyString_FromStringAndSize(NULL, result_len)) == NULL)
+	if ( (result = (PyBytesObject *)
+	      PyBytes_FromStringAndSize(NULL, result_len)) == NULL)
 		return NULL;
-	result_s = PyString_AS_STRING(result);
+	result_s = PyBytes_AS_STRING(result);
 
 	start = self_s;
 	end = self_s + self_len;
@@ -2983,8 +2983,8 @@ replace_single_character(PyStringObject *self,
 }
 
 /* len(self)>=1, len(from)>=2, len(to)>=2, maxcount>=1 */
-Py_LOCAL(PyStringObject *)
-replace_substring(PyStringObject *self,
+Py_LOCAL(PyBytesObject *)
+replace_substring(PyBytesObject *self,
 		  const char *from_s, Py_ssize_t from_len,
 		  const char *to_s, Py_ssize_t to_len,
 		  Py_ssize_t maxcount) {
@@ -2992,10 +2992,10 @@ replace_substring(PyStringObject *self,
 	char *start, *next, *end;
 	Py_ssize_t self_len, result_len;
 	Py_ssize_t count, offset, product;
-	PyStringObject *result;
+	PyBytesObject *result;
 
-	self_s = PyString_AS_STRING(self);
-	self_len = PyString_GET_SIZE(self);
+	self_s = PyBytes_AS_STRING(self);
+	self_len = PyBytes_GET_SIZE(self);
 
 	count = countstring(self_s, self_len,
 			    from_s, from_len,
@@ -3018,10 +3018,10 @@ replace_substring(PyStringObject *self,
 		return NULL;
 	}
 
-	if ( (result = (PyStringObject *)
-	      PyString_FromStringAndSize(NULL, result_len)) == NULL)
+	if ( (result = (PyBytesObject *)
+	      PyBytes_FromStringAndSize(NULL, result_len)) == NULL)
 		return NULL;
-	result_s = PyString_AS_STRING(result);
+	result_s = PyBytes_AS_STRING(result);
 
 	start = self_s;
 	end = self_s + self_len;
@@ -3053,15 +3053,15 @@ replace_substring(PyStringObject *self,
 }
 
 
-Py_LOCAL(PyStringObject *)
-replace(PyStringObject *self,
+Py_LOCAL(PyBytesObject *)
+replace(PyBytesObject *self,
 	const char *from_s, Py_ssize_t from_len,
 	const char *to_s, Py_ssize_t to_len,
 	Py_ssize_t maxcount)
 {
 	if (maxcount < 0) {
 		maxcount = PY_SSIZE_T_MAX;
-	} else if (maxcount == 0 || PyString_GET_SIZE(self) == 0) {
+	} else if (maxcount == 0 || PyBytes_GET_SIZE(self) == 0) {
 		/* nothing to do; return the original string */
 		return return_self(self);
 	}
@@ -3084,7 +3084,7 @@ replace(PyStringObject *self,
 	/* Except for "".replace("", "A") == "A" there is no way beyond this */
 	/* point for an empty self string to generate a non-empty string */
 	/* Special case so the remaining code always gets a non-empty string */
-	if (PyString_GET_SIZE(self) == 0) {
+	if (PyBytes_GET_SIZE(self) == 0) {
 		return return_self(self);
 	}
 
@@ -3131,7 +3131,7 @@ old replaced by new.  If the optional argument count is\n\
 given, only the first count occurrences are replaced.");
 
 static PyObject *
-string_replace(PyStringObject *self, PyObject *args)
+string_replace(PyBytesObject *self, PyObject *args)
 {
 	Py_ssize_t count = -1;
 	PyObject *from, *to;
@@ -3141,9 +3141,9 @@ string_replace(PyStringObject *self, PyObject *args)
 	if (!PyArg_ParseTuple(args, "OO|n:replace", &from, &to, &count))
 		return NULL;
 
-	if (PyString_Check(from)) {
-		from_s = PyString_AS_STRING(from);
-		from_len = PyString_GET_SIZE(from);
+	if (PyBytes_Check(from)) {
+		from_s = PyBytes_AS_STRING(from);
+		from_len = PyBytes_GET_SIZE(from);
 	}
 #ifdef Py_USING_UNICODE
 	if (PyUnicode_Check(from))
@@ -3153,9 +3153,9 @@ string_replace(PyStringObject *self, PyObject *args)
 	else if (PyObject_AsCharBuffer(from, &from_s, &from_len))
 		return NULL;
 
-	if (PyString_Check(to)) {
-		to_s = PyString_AS_STRING(to);
-		to_len = PyString_GET_SIZE(to);
+	if (PyBytes_Check(to)) {
+		to_s = PyBytes_AS_STRING(to);
+		to_len = PyBytes_GET_SIZE(to);
 	}
 #ifdef Py_USING_UNICODE
 	else if (PyUnicode_Check(to))
@@ -3165,7 +3165,7 @@ string_replace(PyStringObject *self, PyObject *args)
 	else if (PyObject_AsCharBuffer(to, &to_s, &to_len))
 		return NULL;
 
-	return (PyObject *)replace((PyStringObject *) self,
+	return (PyObject *)replace((PyBytesObject *) self,
 				   from_s, from_len,
 				   to_s, to_len, count);
 }
@@ -3177,17 +3177,17 @@ string_replace(PyStringObject *self, PyObject *args)
  * -1 on error, 0 if not found and 1 if found.
  */
 Py_LOCAL(int)
-_string_tailmatch(PyStringObject *self, PyObject *substr, Py_ssize_t start,
+_string_tailmatch(PyBytesObject *self, PyObject *substr, Py_ssize_t start,
 		  Py_ssize_t end, int direction)
 {
-	Py_ssize_t len = PyString_GET_SIZE(self);
+	Py_ssize_t len = PyBytes_GET_SIZE(self);
 	Py_ssize_t slen;
 	const char* sub;
 	const char* str;
 
-	if (PyString_Check(substr)) {
-		sub = PyString_AS_STRING(substr);
-		slen = PyString_GET_SIZE(substr);
+	if (PyBytes_Check(substr)) {
+		sub = PyBytes_AS_STRING(substr);
+		slen = PyBytes_GET_SIZE(substr);
 	}
 #ifdef Py_USING_UNICODE
 	else if (PyUnicode_Check(substr))
@@ -3196,7 +3196,7 @@ _string_tailmatch(PyStringObject *self, PyObject *substr, Py_ssize_t start,
 #endif
 	else if (PyObject_AsCharBuffer(substr, &sub, &slen))
 		return -1;
-	str = PyString_AS_STRING(self);
+	str = PyBytes_AS_STRING(self);
 
 	string_adjust_indices(&start, &end, len);
 
@@ -3227,7 +3227,7 @@ With optional end, stop comparing S at that position.\n\
 prefix can also be a tuple of strings to try.");
 
 static PyObject *
-string_startswith(PyStringObject *self, PyObject *args)
+string_startswith(PyBytesObject *self, PyObject *args)
 {
 	Py_ssize_t start = 0;
 	Py_ssize_t end = PY_SSIZE_T_MAX;
@@ -3268,7 +3268,7 @@ With optional end, stop comparing S at that position.\n\
 suffix can also be a tuple of strings to try.");
 
 static PyObject *
-string_endswith(PyStringObject *self, PyObject *args)
+string_endswith(PyBytesObject *self, PyObject *args)
 {
 	Py_ssize_t start = 0;
 	Py_ssize_t end = PY_SSIZE_T_MAX;
@@ -3311,7 +3311,7 @@ a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and\n\
 codecs.register_error that is able to handle UnicodeEncodeErrors.");
 
 static PyObject *
-string_encode(PyStringObject *self, PyObject *args)
+string_encode(PyBytesObject *self, PyObject *args)
 {
     char *encoding = NULL;
     char *errors = NULL;
@@ -3319,10 +3319,10 @@ string_encode(PyStringObject *self, PyObject *args)
 
     if (!PyArg_ParseTuple(args, "|ss:encode", &encoding, &errors))
         return NULL;
-    v = PyString_AsEncodedObject((PyObject *)self, encoding, errors);
+    v = PyBytes_AsEncodedObject((PyObject *)self, encoding, errors);
     if (v == NULL)
         goto onError;
-    if (!PyString_Check(v) && !PyUnicode_Check(v)) {
+    if (!PyBytes_Check(v) && !PyUnicode_Check(v)) {
         PyErr_Format(PyExc_TypeError,
                      "encoder did not return a string/unicode object "
                      "(type=%.400s)",
@@ -3348,7 +3348,7 @@ as well as any other name registerd with codecs.register_error that is\n\
 able to handle UnicodeDecodeErrors.");
 
 static PyObject *
-string_decode(PyStringObject *self, PyObject *args)
+string_decode(PyBytesObject *self, PyObject *args)
 {
     char *encoding = NULL;
     char *errors = NULL;
@@ -3356,10 +3356,10 @@ string_decode(PyStringObject *self, PyObject *args)
 
     if (!PyArg_ParseTuple(args, "|ss:decode", &encoding, &errors))
         return NULL;
-    v = PyString_AsDecodedObject((PyObject *)self, encoding, errors);
+    v = PyBytes_AsDecodedObject((PyObject *)self, encoding, errors);
     if (v == NULL)
         goto onError;
-    if (!PyString_Check(v) && !PyUnicode_Check(v)) {
+    if (!PyBytes_Check(v) && !PyUnicode_Check(v)) {
         PyErr_Format(PyExc_TypeError,
                      "decoder did not return a string/unicode object "
                      "(type=%.400s)",
@@ -3381,7 +3381,7 @@ Return a copy of S where all tab characters are expanded using spaces.\n\
 If tabsize is not given, a tab size of 8 characters is assumed.");
 
 static PyObject*
-string_expandtabs(PyStringObject *self, PyObject *args)
+string_expandtabs(PyBytesObject *self, PyObject *args)
 {
     const char *e, *p, *qe;
     char *q;
@@ -3395,8 +3395,8 @@ string_expandtabs(PyStringObject *self, PyObject *args)
     /* First pass: determine size of output string */
     i = 0; /* chars up to and including most recent \n or \r */
     j = 0; /* chars since most recent \n or \r (use in tab calculations) */
-    e = PyString_AS_STRING(self) + PyString_GET_SIZE(self); /* end of input */
-    for (p = PyString_AS_STRING(self); p < e; p++)
+    e = PyBytes_AS_STRING(self) + PyBytes_GET_SIZE(self); /* end of input */
+    for (p = PyBytes_AS_STRING(self); p < e; p++)
         if (*p == '\t') {
 	    if (tabsize > 0) {
 		incr = tabsize - (j % tabsize);
@@ -3421,15 +3421,15 @@ string_expandtabs(PyStringObject *self, PyObject *args)
 	goto overflow1;
 
     /* Second pass: create output string and fill it */
-    u = PyString_FromStringAndSize(NULL, i + j);
+    u = PyBytes_FromStringAndSize(NULL, i + j);
     if (!u)
         return NULL;
 
     j = 0; /* same as in first pass */
-    q = PyString_AS_STRING(u); /* next output char */
-    qe = PyString_AS_STRING(u) + PyString_GET_SIZE(u); /* end of output */
+    q = PyBytes_AS_STRING(u); /* next output char */
+    qe = PyBytes_AS_STRING(u) + PyBytes_GET_SIZE(u); /* end of output */
 
-    for (p = PyString_AS_STRING(self); p < e; p++)
+    for (p = PyBytes_AS_STRING(self); p < e; p++)
         if (*p == '\t') {
 	    if (tabsize > 0) {
 		i = tabsize - (j % tabsize);
@@ -3460,7 +3460,7 @@ string_expandtabs(PyStringObject *self, PyObject *args)
 }
 
 Py_LOCAL_INLINE(PyObject *)
-pad(PyStringObject *self, Py_ssize_t left, Py_ssize_t right, char fill)
+pad(PyBytesObject *self, Py_ssize_t left, Py_ssize_t right, char fill)
 {
     PyObject *u;
 
@@ -3469,21 +3469,21 @@ pad(PyStringObject *self, Py_ssize_t left, Py_ssize_t right, char fill)
     if (right < 0)
         right = 0;
 
-    if (left == 0 && right == 0 && PyString_CheckExact(self)) {
+    if (left == 0 && right == 0 && PyBytes_CheckExact(self)) {
         Py_INCREF(self);
         return (PyObject *)self;
     }
 
-    u = PyString_FromStringAndSize(NULL,
-				   left + PyString_GET_SIZE(self) + right);
+    u = PyBytes_FromStringAndSize(NULL,
+				   left + PyBytes_GET_SIZE(self) + right);
     if (u) {
         if (left)
-            memset(PyString_AS_STRING(u), fill, left);
-        Py_MEMCPY(PyString_AS_STRING(u) + left,
-	       PyString_AS_STRING(self),
-	       PyString_GET_SIZE(self));
+            memset(PyBytes_AS_STRING(u), fill, left);
+        Py_MEMCPY(PyBytes_AS_STRING(u) + left,
+	       PyBytes_AS_STRING(self),
+	       PyBytes_GET_SIZE(self));
         if (right)
-            memset(PyString_AS_STRING(u) + left + PyString_GET_SIZE(self),
+            memset(PyBytes_AS_STRING(u) + left + PyBytes_GET_SIZE(self),
 		   fill, right);
     }
 
@@ -3497,7 +3497,7 @@ PyDoc_STRVAR(ljust__doc__,
 "done using the specified fill character (default is a space).");
 
 static PyObject *
-string_ljust(PyStringObject *self, PyObject *args)
+string_ljust(PyBytesObject *self, PyObject *args)
 {
     Py_ssize_t width;
     char fillchar = ' ';
@@ -3505,12 +3505,12 @@ string_ljust(PyStringObject *self, PyObject *args)
     if (!PyArg_ParseTuple(args, "n|c:ljust", &width, &fillchar))
         return NULL;
 
-    if (PyString_GET_SIZE(self) >= width && PyString_CheckExact(self)) {
+    if (PyBytes_GET_SIZE(self) >= width && PyBytes_CheckExact(self)) {
         Py_INCREF(self);
         return (PyObject*) self;
     }
 
-    return pad(self, 0, width - PyString_GET_SIZE(self), fillchar);
+    return pad(self, 0, width - PyBytes_GET_SIZE(self), fillchar);
 }
 
 
@@ -3521,7 +3521,7 @@ PyDoc_STRVAR(rjust__doc__,
 "done using the specified fill character (default is a space)");
 
 static PyObject *
-string_rjust(PyStringObject *self, PyObject *args)
+string_rjust(PyBytesObject *self, PyObject *args)
 {
     Py_ssize_t width;
     char fillchar = ' ';
@@ -3529,12 +3529,12 @@ string_rjust(PyStringObject *self, PyObject *args)
     if (!PyArg_ParseTuple(args, "n|c:rjust", &width, &fillchar))
         return NULL;
 
-    if (PyString_GET_SIZE(self) >= width && PyString_CheckExact(self)) {
+    if (PyBytes_GET_SIZE(self) >= width && PyBytes_CheckExact(self)) {
         Py_INCREF(self);
         return (PyObject*) self;
     }
 
-    return pad(self, width - PyString_GET_SIZE(self), 0, fillchar);
+    return pad(self, width - PyBytes_GET_SIZE(self), 0, fillchar);
 }
 
 
@@ -3545,7 +3545,7 @@ PyDoc_STRVAR(center__doc__,
 "done using the specified fill character (default is a space)");
 
 static PyObject *
-string_center(PyStringObject *self, PyObject *args)
+string_center(PyBytesObject *self, PyObject *args)
 {
     Py_ssize_t marg, left;
     Py_ssize_t width;
@@ -3554,12 +3554,12 @@ string_center(PyStringObject *self, PyObject *args)
     if (!PyArg_ParseTuple(args, "n|c:center", &width, &fillchar))
         return NULL;
 
-    if (PyString_GET_SIZE(self) >= width && PyString_CheckExact(self)) {
+    if (PyBytes_GET_SIZE(self) >= width && PyBytes_CheckExact(self)) {
         Py_INCREF(self);
         return (PyObject*) self;
     }
 
-    marg = width - PyString_GET_SIZE(self);
+    marg = width - PyBytes_GET_SIZE(self);
     left = marg / 2 + (marg & width & 1);
 
     return pad(self, left, marg - left, fillchar);
@@ -3572,7 +3572,7 @@ PyDoc_STRVAR(zfill__doc__,
 "of the specified width.  The string S is never truncated.");
 
 static PyObject *
-string_zfill(PyStringObject *self, PyObject *args)
+string_zfill(PyBytesObject *self, PyObject *args)
 {
     Py_ssize_t fill;
     PyObject *s;
@@ -3582,26 +3582,26 @@ string_zfill(PyStringObject *self, PyObject *args)
     if (!PyArg_ParseTuple(args, "n:zfill", &width))
         return NULL;
 
-    if (PyString_GET_SIZE(self) >= width) {
-        if (PyString_CheckExact(self)) {
+    if (PyBytes_GET_SIZE(self) >= width) {
+        if (PyBytes_CheckExact(self)) {
             Py_INCREF(self);
             return (PyObject*) self;
         }
         else
-            return PyString_FromStringAndSize(
-                PyString_AS_STRING(self),
-                PyString_GET_SIZE(self)
+            return PyBytes_FromStringAndSize(
+                PyBytes_AS_STRING(self),
+                PyBytes_GET_SIZE(self)
             );
     }
 
-    fill = width - PyString_GET_SIZE(self);
+    fill = width - PyBytes_GET_SIZE(self);
 
     s = pad(self, fill, 0, '0');
 
     if (s == NULL)
         return NULL;
 
-    p = PyString_AS_STRING(s);
+    p = PyBytes_AS_STRING(s);
     if (p[fill] == '+' || p[fill] == '-') {
         /* move sign to beginning of string */
         p[0] = p[fill];
@@ -3618,22 +3618,22 @@ Return True if all characters in S are whitespace\n\
 and there is at least one character in S, False otherwise.");
 
 static PyObject*
-string_isspace(PyStringObject *self)
+string_isspace(PyBytesObject *self)
 {
     register const unsigned char *p
-        = (unsigned char *) PyString_AS_STRING(self);
+        = (unsigned char *) PyBytes_AS_STRING(self);
     register const unsigned char *e;
 
     /* Shortcut for single character strings */
-    if (PyString_GET_SIZE(self) == 1 &&
+    if (PyBytes_GET_SIZE(self) == 1 &&
 	isspace(*p))
 	return PyBool_FromLong(1);
 
     /* Special case for empty strings */
-    if (PyString_GET_SIZE(self) == 0)
+    if (PyBytes_GET_SIZE(self) == 0)
 	return PyBool_FromLong(0);
 
-    e = p + PyString_GET_SIZE(self);
+    e = p + PyBytes_GET_SIZE(self);
     for (; p < e; p++) {
 	if (!isspace(*p))
 	    return PyBool_FromLong(0);
@@ -3649,22 +3649,22 @@ Return True if all characters in S are alphabetic\n\
 and there is at least one character in S, False otherwise.");
 
 static PyObject*
-string_isalpha(PyStringObject *self)
+string_isalpha(PyBytesObject *self)
 {
     register const unsigned char *p
-        = (unsigned char *) PyString_AS_STRING(self);
+        = (unsigned char *) PyBytes_AS_STRING(self);
     register const unsigned char *e;
 
     /* Shortcut for single character strings */
-    if (PyString_GET_SIZE(self) == 1 &&
+    if (PyBytes_GET_SIZE(self) == 1 &&
 	isalpha(*p))
 	return PyBool_FromLong(1);
 
     /* Special case for empty strings */
-    if (PyString_GET_SIZE(self) == 0)
+    if (PyBytes_GET_SIZE(self) == 0)
 	return PyBool_FromLong(0);
 
-    e = p + PyString_GET_SIZE(self);
+    e = p + PyBytes_GET_SIZE(self);
     for (; p < e; p++) {
 	if (!isalpha(*p))
 	    return PyBool_FromLong(0);
@@ -3680,22 +3680,22 @@ Return True if all characters in S are alphanumeric\n\
 and there is at least one character in S, False otherwise.");
 
 static PyObject*
-string_isalnum(PyStringObject *self)
+string_isalnum(PyBytesObject *self)
 {
     register const unsigned char *p
-        = (unsigned char *) PyString_AS_STRING(self);
+        = (unsigned char *) PyBytes_AS_STRING(self);
     register const unsigned char *e;
 
     /* Shortcut for single character strings */
-    if (PyString_GET_SIZE(self) == 1 &&
+    if (PyBytes_GET_SIZE(self) == 1 &&
 	isalnum(*p))
 	return PyBool_FromLong(1);
 
     /* Special case for empty strings */
-    if (PyString_GET_SIZE(self) == 0)
+    if (PyBytes_GET_SIZE(self) == 0)
 	return PyBool_FromLong(0);
 
-    e = p + PyString_GET_SIZE(self);
+    e = p + PyBytes_GET_SIZE(self);
     for (; p < e; p++) {
 	if (!isalnum(*p))
 	    return PyBool_FromLong(0);
@@ -3711,22 +3711,22 @@ Return True if all characters in S are digits\n\
 and there is at least one character in S, False otherwise.");
 
 static PyObject*
-string_isdigit(PyStringObject *self)
+string_isdigit(PyBytesObject *self)
 {
     register const unsigned char *p
-        = (unsigned char *) PyString_AS_STRING(self);
+        = (unsigned char *) PyBytes_AS_STRING(self);
     register const unsigned char *e;
 
     /* Shortcut for single character strings */
-    if (PyString_GET_SIZE(self) == 1 &&
+    if (PyBytes_GET_SIZE(self) == 1 &&
 	isdigit(*p))
 	return PyBool_FromLong(1);
 
     /* Special case for empty strings */
-    if (PyString_GET_SIZE(self) == 0)
+    if (PyBytes_GET_SIZE(self) == 0)
 	return PyBool_FromLong(0);
 
-    e = p + PyString_GET_SIZE(self);
+    e = p + PyBytes_GET_SIZE(self);
     for (; p < e; p++) {
 	if (!isdigit(*p))
 	    return PyBool_FromLong(0);
@@ -3742,22 +3742,22 @@ Return True if all cased characters in S are lowercase and there is\n\
 at least one cased character in S, False otherwise.");
 
 static PyObject*
-string_islower(PyStringObject *self)
+string_islower(PyBytesObject *self)
 {
     register const unsigned char *p
-        = (unsigned char *) PyString_AS_STRING(self);
+        = (unsigned char *) PyBytes_AS_STRING(self);
     register const unsigned char *e;
     int cased;
 
     /* Shortcut for single character strings */
-    if (PyString_GET_SIZE(self) == 1)
+    if (PyBytes_GET_SIZE(self) == 1)
 	return PyBool_FromLong(islower(*p) != 0);
 
     /* Special case for empty strings */
-    if (PyString_GET_SIZE(self) == 0)
+    if (PyBytes_GET_SIZE(self) == 0)
 	return PyBool_FromLong(0);
 
-    e = p + PyString_GET_SIZE(self);
+    e = p + PyBytes_GET_SIZE(self);
     cased = 0;
     for (; p < e; p++) {
 	if (isupper(*p))
@@ -3776,22 +3776,22 @@ Return True if all cased characters in S are uppercase and there is\n\
 at least one cased character in S, False otherwise.");
 
 static PyObject*
-string_isupper(PyStringObject *self)
+string_isupper(PyBytesObject *self)
 {
     register const unsigned char *p
-        = (unsigned char *) PyString_AS_STRING(self);
+        = (unsigned char *) PyBytes_AS_STRING(self);
     register const unsigned char *e;
     int cased;
 
     /* Shortcut for single character strings */
-    if (PyString_GET_SIZE(self) == 1)
+    if (PyBytes_GET_SIZE(self) == 1)
 	return PyBool_FromLong(isupper(*p) != 0);
 
     /* Special case for empty strings */
-    if (PyString_GET_SIZE(self) == 0)
+    if (PyBytes_GET_SIZE(self) == 0)
 	return PyBool_FromLong(0);
 
-    e = p + PyString_GET_SIZE(self);
+    e = p + PyBytes_GET_SIZE(self);
     cased = 0;
     for (; p < e; p++) {
 	if (islower(*p))
@@ -3812,22 +3812,22 @@ characters and lowercase characters only cased ones. Return False\n\
 otherwise.");
 
 static PyObject*
-string_istitle(PyStringObject *self, PyObject *uncased)
+string_istitle(PyBytesObject *self, PyObject *uncased)
 {
     register const unsigned char *p
-        = (unsigned char *) PyString_AS_STRING(self);
+        = (unsigned char *) PyBytes_AS_STRING(self);
     register const unsigned char *e;
     int cased, previous_is_cased;
 
     /* Shortcut for single character strings */
-    if (PyString_GET_SIZE(self) == 1)
+    if (PyBytes_GET_SIZE(self) == 1)
 	return PyBool_FromLong(isupper(*p) != 0);
 
     /* Special case for empty strings */
-    if (PyString_GET_SIZE(self) == 0)
+    if (PyBytes_GET_SIZE(self) == 0)
 	return PyBool_FromLong(0);
 
-    e = p + PyString_GET_SIZE(self);
+    e = p + PyBytes_GET_SIZE(self);
     cased = 0;
     previous_is_cased = 0;
     for (; p < e; p++) {
@@ -3860,7 +3860,7 @@ Line breaks are not included in the resulting list unless keepends\n\
 is given and true.");
 
 static PyObject*
-string_splitlines(PyStringObject *self, PyObject *args)
+string_splitlines(PyBytesObject *self, PyObject *args)
 {
     register Py_ssize_t i;
     register Py_ssize_t j;
@@ -3873,8 +3873,8 @@ string_splitlines(PyStringObject *self, PyObject *args)
     if (!PyArg_ParseTuple(args, "|i:splitlines", &keepends))
         return NULL;
 
-    data = PyString_AS_STRING(self);
-    len = PyString_GET_SIZE(self);
+    data = PyBytes_AS_STRING(self);
+    len = PyBytes_GET_SIZE(self);
 
     /* This does not use the preallocated list because splitlines is
        usually run with hundreds of newlines.  The overhead of
@@ -3926,7 +3926,7 @@ string_splitlines(PyStringObject *self, PyObject *args)
 #undef PREALLOC_SIZE
 
 static PyObject *
-string_getnewargs(PyStringObject *v)
+string_getnewargs(PyBytesObject *v)
 {
 	return Py_BuildValue("(s#)", v->ob_sval, Py_SIZE(v));
 }
@@ -4011,12 +4011,12 @@ string_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 	PyObject *x = NULL;
 	static char *kwlist[] = {"object", 0};
 
-	if (type != &PyString_Type)
+	if (type != &PyBytes_Type)
 		return str_subtype_new(type, args, kwds);
 	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:str", kwlist, &x))
 		return NULL;
 	if (x == NULL)
-		return PyString_FromString("");
+		return PyBytes_FromString("");
 	return PyObject_Str(x);
 }
 
@@ -4026,18 +4026,18 @@ str_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 	PyObject *tmp, *pnew;
 	Py_ssize_t n;
 
-	assert(PyType_IsSubtype(type, &PyString_Type));
-	tmp = string_new(&PyString_Type, args, kwds);
+	assert(PyType_IsSubtype(type, &PyBytes_Type));
+	tmp = string_new(&PyBytes_Type, args, kwds);
 	if (tmp == NULL)
 		return NULL;
-	assert(PyString_CheckExact(tmp));
-	n = PyString_GET_SIZE(tmp);
+	assert(PyBytes_CheckExact(tmp));
+	n = PyBytes_GET_SIZE(tmp);
 	pnew = type->tp_alloc(type, n);
 	if (pnew != NULL) {
-		Py_MEMCPY(PyString_AS_STRING(pnew), PyString_AS_STRING(tmp), n+1);
-		((PyStringObject *)pnew)->ob_shash =
-			((PyStringObject *)tmp)->ob_shash;
-		((PyStringObject *)pnew)->ob_sstate = SSTATE_NOT_INTERNED;
+		Py_MEMCPY(PyBytes_AS_STRING(pnew), PyBytes_AS_STRING(tmp), n+1);
+		((PyBytesObject *)pnew)->ob_shash =
+			((PyBytesObject *)tmp)->ob_shash;
+		((PyBytesObject *)pnew)->ob_sstate = SSTATE_NOT_INTERNED;
 	}
 	Py_DECREF(tmp);
 	return pnew;
@@ -4054,11 +4054,11 @@ basestring_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 static PyObject *
 string_mod(PyObject *v, PyObject *w)
 {
-	if (!PyString_Check(v)) {
+	if (!PyBytes_Check(v)) {
 		Py_INCREF(Py_NotImplemented);
 		return Py_NotImplemented;
 	}
-	return PyString_Format(v, w);
+	return PyBytes_Format(v, w);
 }
 
 PyDoc_STRVAR(basestring_doc,
@@ -4121,10 +4121,10 @@ PyDoc_STRVAR(string_doc,
 Return a nice string representation of the object.\n\
 If the argument is a string, the return value is the same object.");
 
-PyTypeObject PyString_Type = {
+PyTypeObject PyBytes_Type = {
 	PyVarObject_HEAD_INIT(&PyType_Type, 0)
 	"str",
-	sizeof(PyStringObject),
+	sizeof(PyBytesObject),
 	sizeof(char),
  	string_dealloc, 			/* tp_dealloc */
 	(printfunc)string_print, 		/* tp_print */
@@ -4166,25 +4166,25 @@ PyTypeObject PyString_Type = {
 };
 
 void
-PyString_Concat(register PyObject **pv, register PyObject *w)
+PyBytes_Concat(register PyObject **pv, register PyObject *w)
 {
 	register PyObject *v;
 	if (*pv == NULL)
 		return;
-	if (w == NULL || !PyString_Check(*pv)) {
+	if (w == NULL || !PyBytes_Check(*pv)) {
 		Py_DECREF(*pv);
 		*pv = NULL;
 		return;
 	}
-	v = string_concat((PyStringObject *) *pv, w);
+	v = string_concat((PyBytesObject *) *pv, w);
 	Py_DECREF(*pv);
 	*pv = v;
 }
 
 void
-PyString_ConcatAndDel(register PyObject **pv, register PyObject *w)
+PyBytes_ConcatAndDel(register PyObject **pv, register PyObject *w)
 {
-	PyString_Concat(pv, w);
+	PyBytes_Concat(pv, w);
 	Py_XDECREF(w);
 }
 
@@ -4204,13 +4204,13 @@ PyString_ConcatAndDel(register PyObject **pv, register PyObject *w)
 */
 
 int
-_PyString_Resize(PyObject **pv, Py_ssize_t newsize)
+_PyBytes_Resize(PyObject **pv, Py_ssize_t newsize)
 {
 	register PyObject *v;
-	register PyStringObject *sv;
+	register PyBytesObject *sv;
 	v = *pv;
-	if (!PyString_Check(v) || Py_REFCNT(v) != 1 || newsize < 0 ||
-	    PyString_CHECK_INTERNED(v)) {
+	if (!PyBytes_Check(v) || Py_REFCNT(v) != 1 || newsize < 0 ||
+	    PyBytes_CHECK_INTERNED(v)) {
 		*pv = 0;
 		Py_DECREF(v);
 		PyErr_BadInternalCall();
@@ -4220,14 +4220,14 @@ _PyString_Resize(PyObject **pv, Py_ssize_t newsize)
 	_Py_DEC_REFTOTAL;
 	_Py_ForgetReference(v);
 	*pv = (PyObject *)
-		PyObject_REALLOC((char *)v, sizeof(PyStringObject) + newsize);
+		PyObject_REALLOC((char *)v, sizeof(PyBytesObject) + newsize);
 	if (*pv == NULL) {
 		PyObject_Del(v);
 		PyErr_NoMemory();
 		return -1;
 	}
 	_Py_NewReference(*pv);
-	sv = (PyStringObject *) *pv;
+	sv = (PyBytesObject *) *pv;
 	Py_SIZE(sv) = newsize;
 	sv->ob_sval[newsize] = '\0';
 	sv->ob_shash = -1;	/* invalidate cached hash value */
@@ -4313,7 +4313,7 @@ formatfloat(char *buf, size_t buflen, int flags,
 	return (int)strlen(buf);
 }
 
-/* _PyString_FormatLong emulates the format codes d, u, o, x and X, and
+/* _PyBytes_FormatLong emulates the format codes d, u, o, x and X, and
  * the F_ALT flag, for Python's long (unbounded) ints.  It's not used for
  * Python's regular ints.
  * Return value:  a new PyString*, or NULL if error.
@@ -4335,7 +4335,7 @@ formatfloat(char *buf, size_t buflen, int flags,
  * produce a '-' sign, but can for Python's unbounded ints.
  */
 PyObject*
-_PyString_FormatLong(PyObject *val, int flags, int prec, int type,
+_PyBytes_FormatLong(PyObject *val, int flags, int prec, int type,
 		     char **pbuf, int *plen)
 {
 	PyObject *result = NULL;
@@ -4366,7 +4366,7 @@ _PyString_FormatLong(PyObject *val, int flags, int prec, int type,
 	if (!result)
 		return NULL;
 
-	buf = PyString_AsString(result);
+	buf = PyBytes_AsString(result);
 	if (!buf) {
 		Py_DECREF(result);
 		return NULL;
@@ -4377,9 +4377,9 @@ _PyString_FormatLong(PyObject *val, int flags, int prec, int type,
 		PyErr_BadInternalCall();
 		return NULL;
 	}
-	llen = PyString_Size(result);
+	llen = PyBytes_Size(result);
 	if (llen > INT_MAX) {
-		PyErr_SetString(PyExc_ValueError, "string too large in _PyString_FormatLong");
+		PyErr_SetString(PyExc_ValueError, "string too large in _PyBytes_FormatLong");
 		return NULL;
 	}
 	len = (int)llen;
@@ -4425,14 +4425,14 @@ _PyString_FormatLong(PyObject *val, int flags, int prec, int type,
 
 	/* Fill with leading zeroes to meet minimum width. */
 	if (prec > numdigits) {
-		PyObject *r1 = PyString_FromStringAndSize(NULL,
+		PyObject *r1 = PyBytes_FromStringAndSize(NULL,
 					numnondigits + prec);
 		char *b1;
 		if (!r1) {
 			Py_DECREF(result);
 			return NULL;
 		}
-		b1 = PyString_AS_STRING(r1);
+		b1 = PyBytes_AS_STRING(r1);
 		for (i = 0; i < numnondigits; ++i)
 			*b1++ = *buf++;
 		for (i = 0; i < prec - numdigits; i++)
@@ -4442,7 +4442,7 @@ _PyString_FormatLong(PyObject *val, int flags, int prec, int type,
 		*b1 = '\0';
 		Py_DECREF(result);
 		result = r1;
-		buf = PyString_AS_STRING(result);
+		buf = PyBytes_AS_STRING(result);
 		len = numnondigits + prec;
 	}
 
@@ -4536,7 +4536,7 @@ Py_LOCAL_INLINE(int)
 formatchar(char *buf, size_t buflen, PyObject *v)
 {
 	/* presume that the buffer is at least 2 characters long */
-	if (PyString_Check(v)) {
+	if (PyBytes_Check(v)) {
 		if (!PyArg_Parse(v, "c;%c requires int or char", &buf[0]))
 			return -1;
 	}
@@ -4559,7 +4559,7 @@ formatchar(char *buf, size_t buflen, PyObject *v)
 #define FORMATBUFLEN (size_t)120
 
 PyObject *
-PyString_Format(PyObject *format, PyObject *args)
+PyBytes_Format(PyObject *format, PyObject *args)
 {
 	char *fmt, *res;
 	Py_ssize_t arglen, argidx;
@@ -4570,18 +4570,18 @@ PyString_Format(PyObject *format, PyObject *args)
 	PyObject *v, *w;
 #endif
 	PyObject *dict = NULL;
-	if (format == NULL || !PyString_Check(format) || args == NULL) {
+	if (format == NULL || !PyBytes_Check(format) || args == NULL) {
 		PyErr_BadInternalCall();
 		return NULL;
 	}
 	orig_args = args;
-	fmt = PyString_AS_STRING(format);
-	fmtcnt = PyString_GET_SIZE(format);
+	fmt = PyBytes_AS_STRING(format);
+	fmtcnt = PyBytes_GET_SIZE(format);
 	reslen = rescnt = fmtcnt + 100;
-	result = PyString_FromStringAndSize((char *)NULL, reslen);
+	result = PyBytes_FromStringAndSize((char *)NULL, reslen);
 	if (result == NULL)
 		return NULL;
-	res = PyString_AsString(result);
+	res = PyBytes_AsString(result);
 	if (PyTuple_Check(args)) {
 		arglen = PyTuple_GET_SIZE(args);
 		argidx = 0;
@@ -4598,9 +4598,9 @@ PyString_Format(PyObject *format, PyObject *args)
 			if (--rescnt < 0) {
 				rescnt = fmtcnt + 100;
 				reslen += rescnt;
-				if (_PyString_Resize(&result, reslen) < 0)
+				if (_PyBytes_Resize(&result, reslen) < 0)
 					return NULL;
-				res = PyString_AS_STRING(result)
+				res = PyBytes_AS_STRING(result)
 					+ reslen - rescnt;
 				--rescnt;
 			}
@@ -4655,7 +4655,7 @@ PyString_Format(PyObject *format, PyObject *args)
 						   "incomplete format key");
 					goto error;
 				}
-				key = PyString_FromStringAndSize(keystart,
+				key = PyBytes_FromStringAndSize(keystart,
 								 keylen);
 				if (key == NULL)
 					goto error;
@@ -4796,14 +4796,14 @@ PyString_Format(PyObject *format, PyObject *args)
 					temp = PyObject_Repr(v);
 				if (temp == NULL)
 					goto error;
-				if (!PyString_Check(temp)) {
+				if (!PyBytes_Check(temp)) {
 					PyErr_SetString(PyExc_TypeError,
 					  "%s argument has non-string str()");
 					Py_DECREF(temp);
 					goto error;
 				}
-				pbuf = PyString_AS_STRING(temp);
-				len = PyString_GET_SIZE(temp);
+				pbuf = PyBytes_AS_STRING(temp);
+				len = PyBytes_GET_SIZE(temp);
 				if (prec >= 0 && len > prec)
 					len = prec;
 				break;
@@ -4843,7 +4843,7 @@ PyString_Format(PyObject *format, PyObject *args)
 							int ilen;
 							
 							isnumok = 1;
-							temp = _PyString_FormatLong(iobj, flags,
+							temp = _PyBytes_FormatLong(iobj, flags,
 								prec, c, &pbuf, &ilen);
 							Py_DECREF(iobj);
 							len = ilen;
@@ -4901,7 +4901,7 @@ PyString_Format(PyObject *format, PyObject *args)
 				  "at index %zd",
 				  c, c,
 				  (Py_ssize_t)(fmt - 1 -
-					       PyString_AsString(format)));
+					       PyBytes_AsString(format)));
 				goto error;
 			}
 			if (sign) {
@@ -4927,11 +4927,11 @@ PyString_Format(PyObject *format, PyObject *args)
 					Py_XDECREF(temp);
 					return PyErr_NoMemory();
 				}
-				if (_PyString_Resize(&result, reslen) < 0) {
+				if (_PyBytes_Resize(&result, reslen) < 0) {
 					Py_XDECREF(temp);
 					return NULL;
 				}
-				res = PyString_AS_STRING(result)
+				res = PyBytes_AS_STRING(result)
 					+ reslen - rescnt;
 			}
 			if (sign) {
@@ -4995,7 +4995,7 @@ PyString_Format(PyObject *format, PyObject *args)
 	if (args_owned) {
 		Py_DECREF(args);
 	}
-	_PyString_Resize(&result, reslen - rescnt);
+	_PyBytes_Resize(&result, reslen - rescnt);
 	return result;
 
 #ifdef Py_USING_UNICODE
@@ -5024,11 +5024,11 @@ PyString_Format(PyObject *format, PyObject *args)
 	args_owned = 1;
 	/* Take what we have of the result and let the Unicode formatting
 	   function format the rest of the input. */
-	rescnt = res - PyString_AS_STRING(result);
-	if (_PyString_Resize(&result, rescnt))
+	rescnt = res - PyBytes_AS_STRING(result);
+	if (_PyBytes_Resize(&result, rescnt))
 		goto error;
-	fmtcnt = PyString_GET_SIZE(format) - \
-		 (fmt - PyString_AS_STRING(format));
+	fmtcnt = PyBytes_GET_SIZE(format) - \
+		 (fmt - PyBytes_AS_STRING(format));
 	format = PyUnicode_Decode(fmt, fmtcnt, NULL, NULL);
 	if (format == NULL)
 		goto error;
@@ -5054,17 +5054,17 @@ PyString_Format(PyObject *format, PyObject *args)
 }
 
 void
-PyString_InternInPlace(PyObject **p)
+PyBytes_InternInPlace(PyObject **p)
 {
-	register PyStringObject *s = (PyStringObject *)(*p);
+	register PyBytesObject *s = (PyBytesObject *)(*p);
 	PyObject *t;
-	if (s == NULL || !PyString_Check(s))
-		Py_FatalError("PyString_InternInPlace: strings only please!");
+	if (s == NULL || !PyBytes_Check(s))
+		Py_FatalError("PyBytes_InternInPlace: strings only please!");
 	/* If it's a string subclass, we don't really know what putting
 	   it in the interned dict might do. */
-	if (!PyString_CheckExact(s))
+	if (!PyBytes_CheckExact(s))
 		return;
-	if (PyString_CHECK_INTERNED(s))
+	if (PyBytes_CHECK_INTERNED(s))
 		return;
 	if (interned == NULL) {
 		interned = PyDict_New();
@@ -5088,32 +5088,32 @@ PyString_InternInPlace(PyObject **p)
 	/* The two references in interned are not counted by refcnt.
 	   The string deallocator will take care of this */
 	Py_REFCNT(s) -= 2;
-	PyString_CHECK_INTERNED(s) = SSTATE_INTERNED_MORTAL;
+	PyBytes_CHECK_INTERNED(s) = SSTATE_INTERNED_MORTAL;
 }
 
 void
-PyString_InternImmortal(PyObject **p)
+PyBytes_InternImmortal(PyObject **p)
 {
-	PyString_InternInPlace(p);
-	if (PyString_CHECK_INTERNED(*p) != SSTATE_INTERNED_IMMORTAL) {
-		PyString_CHECK_INTERNED(*p) = SSTATE_INTERNED_IMMORTAL;
+	PyBytes_InternInPlace(p);
+	if (PyBytes_CHECK_INTERNED(*p) != SSTATE_INTERNED_IMMORTAL) {
+		PyBytes_CHECK_INTERNED(*p) = SSTATE_INTERNED_IMMORTAL;
 		Py_INCREF(*p);
 	}
 }
 
 
 PyObject *
-PyString_InternFromString(const char *cp)
+PyBytes_InternFromString(const char *cp)
 {
-	PyObject *s = PyString_FromString(cp);
+	PyObject *s = PyBytes_FromString(cp);
 	if (s == NULL)
 		return NULL;
-	PyString_InternInPlace(&s);
+	PyBytes_InternInPlace(&s);
 	return s;
 }
 
 void
-PyString_Fini(void)
+PyBytes_Fini(void)
 {
 	int i;
 	for (i = 0; i < UCHAR_MAX + 1; i++) {
@@ -5127,7 +5127,7 @@ PyString_Fini(void)
 void _Py_ReleaseInternedStrings(void)
 {
 	PyObject *keys;
-	PyStringObject *s;
+	PyBytesObject *s;
 	Py_ssize_t i, n;
 	Py_ssize_t immortal_size = 0, mortal_size = 0;
 
@@ -5148,7 +5148,7 @@ void _Py_ReleaseInternedStrings(void)
 	fprintf(stderr, "releasing %" PY_FORMAT_SIZE_T "d interned strings\n",
 		n);
 	for (i = 0; i < n; i++) {
-		s = (PyStringObject *) PyList_GET_ITEM(keys, i);
+		s = (PyBytesObject *) PyList_GET_ITEM(keys, i);
 		switch (s->ob_sstate) {
 		case SSTATE_NOT_INTERNED:
 			/* XXX Shouldn't happen */
diff --git a/Objects/structseq.c b/Objects/structseq.c
index b6126ba..c348254 100644
--- a/Objects/structseq.c
+++ b/Objects/structseq.c
@@ -270,7 +270,7 @@ structseq_repr(PyStructSequence *obj)
 			Py_DECREF(tup);
 			return NULL;
 		}
-		crepr = PyString_AsString(repr);
+		crepr = PyBytes_AsString(repr);
 		if (crepr == NULL) {
 			Py_DECREF(tup);
 			Py_DECREF(repr);
@@ -306,7 +306,7 @@ structseq_repr(PyStructSequence *obj)
 	*pbuf++ = ')';
 	*pbuf = '\0';
 
-	return PyString_FromString(buf);
+	return PyBytes_FromString(buf);
 }
 
 static PyObject *
diff --git a/Objects/tupleobject.c b/Objects/tupleobject.c
index e9cb3ef..0524aae 100644
--- a/Objects/tupleobject.c
+++ b/Objects/tupleobject.c
@@ -218,7 +218,7 @@ tuplerepr(PyTupleObject *v)
 
 	n = Py_SIZE(v);
 	if (n == 0)
-		return PyString_FromString("()");
+		return PyBytes_FromString("()");
 
 	/* While not mutable, it is still possible to end up with a cycle in a
 	   tuple through an object that stores itself within a tuple (and thus
@@ -226,7 +226,7 @@ tuplerepr(PyTupleObject *v)
 	   possible within a type. */
 	i = Py_ReprEnter((PyObject *)v);
 	if (i != 0) {
-		return i > 0 ? PyString_FromString("(...)") : NULL;
+		return i > 0 ? PyBytes_FromString("(...)") : NULL;
 	}
 
 	pieces = PyTuple_New(n);
@@ -246,29 +246,29 @@ tuplerepr(PyTupleObject *v)
 
 	/* Add "()" decorations to the first and last items. */
 	assert(n > 0);
-	s = PyString_FromString("(");
+	s = PyBytes_FromString("(");
 	if (s == NULL)
 		goto Done;
 	temp = PyTuple_GET_ITEM(pieces, 0);
-	PyString_ConcatAndDel(&s, temp);
+	PyBytes_ConcatAndDel(&s, temp);
 	PyTuple_SET_ITEM(pieces, 0, s);
 	if (s == NULL)
 		goto Done;
 
-	s = PyString_FromString(n == 1 ? ",)" : ")");
+	s = PyBytes_FromString(n == 1 ? ",)" : ")");
 	if (s == NULL)
 		goto Done;
 	temp = PyTuple_GET_ITEM(pieces, n-1);
-	PyString_ConcatAndDel(&temp, s);
+	PyBytes_ConcatAndDel(&temp, s);
 	PyTuple_SET_ITEM(pieces, n-1, temp);
 	if (temp == NULL)
 		goto Done;
 
 	/* Paste them all together with ", " between. */
-	s = PyString_FromString(", ");
+	s = PyBytes_FromString(", ");
 	if (s == NULL)
 		goto Done;
-	result = _PyString_Join(s, pieces);
+	result = _PyBytes_Join(s, pieces);
 	Py_DECREF(s);	
 
 Done:
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
index c3aa090..2ea3d29 100644
--- a/Objects/typeobject.c
+++ b/Objects/typeobject.c
@@ -19,10 +19,10 @@
 		 >> (8*sizeof(unsigned int) - MCACHE_SIZE_EXP))
 #define MCACHE_HASH_METHOD(type, name)                                  \
 		MCACHE_HASH((type)->tp_version_tag,                     \
-		            ((PyStringObject *)(name))->ob_shash)
+		            ((PyBytesObject *)(name))->ob_shash)
 #define MCACHE_CACHEABLE_NAME(name)                                     \
-		PyString_CheckExact(name) &&                            \
-		PyString_GET_SIZE(name) <= MCACHE_MAX_ATTR_SIZE
+		PyBytes_CheckExact(name) &&                            \
+		PyBytes_GET_SIZE(name) <= MCACHE_MAX_ATTR_SIZE
 
 struct method_cache_entry {
 	unsigned int version;
@@ -218,7 +218,7 @@ type_name(PyTypeObject *type, void *context)
 			s = type->tp_name;
 		else
 			s++;
-		return PyString_FromString(s);
+		return PyBytes_FromString(s);
 	}
 }
 
@@ -237,14 +237,14 @@ type_set_name(PyTypeObject *type, PyObject *value, void *context)
 			     "can't delete %s.__name__", type->tp_name);
 		return -1;
 	}
-	if (!PyString_Check(value)) {
+	if (!PyBytes_Check(value)) {
 		PyErr_Format(PyExc_TypeError,
 			     "can only assign string to %s.__name__, not '%s'",
 			     type->tp_name, Py_TYPE(value)->tp_name);
 		return -1;
 	}
-	if (strlen(PyString_AS_STRING(value))
-	    != (size_t)PyString_GET_SIZE(value)) {
+	if (strlen(PyBytes_AS_STRING(value))
+	    != (size_t)PyBytes_GET_SIZE(value)) {
 		PyErr_Format(PyExc_ValueError,
 			     "__name__ must not contain null bytes");
 		return -1;
@@ -257,7 +257,7 @@ type_set_name(PyTypeObject *type, PyObject *value, void *context)
 	Py_DECREF(et->ht_name);
 	et->ht_name = value;
 
-	type->tp_name = PyString_AS_STRING(value);
+	type->tp_name = PyBytes_AS_STRING(value);
 
 	return 0;
 }
@@ -280,9 +280,9 @@ type_module(PyTypeObject *type, void *context)
 	else {
 		s = strrchr(type->tp_name, '.');
 		if (s != NULL)
-			return PyString_FromStringAndSize(
+			return PyBytes_FromStringAndSize(
 			    type->tp_name, (Py_ssize_t)(s - type->tp_name));
-		return PyString_FromString("__builtin__");
+		return PyBytes_FromString("__builtin__");
 	}
 }
 
@@ -556,7 +556,7 @@ type_get_doc(PyTypeObject *type, void *context)
 {
 	PyObject *result;
 	if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE) && type->tp_doc != NULL)
-		return PyString_FromString(type->tp_doc);
+		return PyBytes_FromString(type->tp_doc);
 	result = PyDict_GetItemString(type->tp_dict, "__doc__");
 	if (result == NULL) {
 		result = Py_None;
@@ -645,7 +645,7 @@ type_repr(PyTypeObject *type)
 	mod = type_module(type, NULL);
 	if (mod == NULL)
 		PyErr_Clear();
-	else if (!PyString_Check(mod)) {
+	else if (!PyBytes_Check(mod)) {
 		Py_DECREF(mod);
 		mod = NULL;
 	}
@@ -658,14 +658,14 @@ type_repr(PyTypeObject *type)
 	else
 		kind = "type";
 
-	if (mod != NULL && strcmp(PyString_AS_STRING(mod), "__builtin__")) {
-		rtn = PyString_FromFormat("<%s '%s.%s'>",
+	if (mod != NULL && strcmp(PyBytes_AS_STRING(mod), "__builtin__")) {
+		rtn = PyBytes_FromFormat("<%s '%s.%s'>",
 					  kind,
-					  PyString_AS_STRING(mod),
-					  PyString_AS_STRING(name));
+					  PyBytes_AS_STRING(mod),
+					  PyBytes_AS_STRING(name));
 	}
 	else
-		rtn = PyString_FromFormat("<%s '%s'>", kind, type->tp_name);
+		rtn = PyBytes_FromFormat("<%s '%s'>", kind, type->tp_name);
 
 	Py_XDECREF(mod);
 	Py_DECREF(name);
@@ -1137,7 +1137,7 @@ lookup_maybe(PyObject *self, char *attrstr, PyObject **attrobj)
 	PyObject *res;
 
 	if (*attrobj == NULL) {
-		*attrobj = PyString_InternFromString(attrstr);
+		*attrobj = PyBytes_InternFromString(attrstr);
 		if (*attrobj == NULL)
 			return NULL;
 	}
@@ -1329,7 +1329,7 @@ class_name(PyObject *cls)
 	}
 	if (name == NULL)
 		return NULL;
-	if (!PyString_Check(name)) {
+	if (!PyBytes_Check(name)) {
 		Py_DECREF(name);
 		return NULL;
 	}
@@ -1351,7 +1351,7 @@ check_duplicates(PyObject *list)
 				o = class_name(o);
 				PyErr_Format(PyExc_TypeError,
 					     "duplicate base class %s",
-					     o ? PyString_AS_STRING(o) : "?");
+					     o ? PyBytes_AS_STRING(o) : "?");
 				Py_XDECREF(o);
 				return -1;
 			}
@@ -1397,7 +1397,7 @@ consistent method resolution\norder (MRO) for bases");
 	while (PyDict_Next(set, &i, &k, &v) && (size_t)off < sizeof(buf)) {
 		PyObject *name = class_name(k);
 		off += PyOS_snprintf(buf + off, sizeof(buf) - off, " %s",
-				     name ? PyString_AS_STRING(name) : "?");
+				     name ? PyBytes_AS_STRING(name) : "?");
 		Py_XDECREF(name);
 		if (--n && (size_t)(off+1) < sizeof(buf)) {
 			buf[off++] = ',';
@@ -1750,7 +1750,7 @@ get_dict_descriptor(PyTypeObject *type)
 	PyObject *descr;
 
 	if (dict_str == NULL) {
-		dict_str = PyString_InternFromString("__dict__");
+		dict_str = PyBytes_InternFromString("__dict__");
 		if (dict_str == NULL)
 			return NULL;
 	}
@@ -1899,14 +1899,14 @@ valid_identifier(PyObject *s)
 	unsigned char *p;
 	Py_ssize_t i, n;
 
-	if (!PyString_Check(s)) {
+	if (!PyBytes_Check(s)) {
 		PyErr_Format(PyExc_TypeError,
 			     "__slots__ items must be strings, not '%.200s'",
 			     Py_TYPE(s)->tp_name);
 		return 0;
 	}
-	p = (unsigned char *) PyString_AS_STRING(s);
-	n = PyString_GET_SIZE(s);
+	p = (unsigned char *) PyBytes_AS_STRING(s);
+	n = PyBytes_GET_SIZE(s);
 	/* We must reject an empty name.  As a hack, we bump the
 	   length to 1 so that the loop will balk on the trailing \0. */
 	if (n == 0)
@@ -2108,7 +2108,7 @@ type_new(PyTypeObject *metatype, PyObject *args, PyObject *kwds)
 		/* Have slots */
 
 		/* Make it into a tuple */
-		if (PyString_Check(slots) || PyUnicode_Check(slots))
+		if (PyBytes_Check(slots) || PyUnicode_Check(slots))
 			slots = PyTuple_Pack(1, slots);
 		else
 			slots = PySequence_Tuple(slots);
@@ -2146,8 +2146,8 @@ type_new(PyTypeObject *metatype, PyObject *args, PyObject *kwds)
 			char *s;
 			if (!valid_identifier(tmp))
 				goto bad_slots;
-			assert(PyString_Check(tmp));
-			s = PyString_AS_STRING(tmp);
+			assert(PyBytes_Check(tmp));
+			s = PyBytes_AS_STRING(tmp);
 			if (strcmp(s, "__dict__") == 0) {
 				if (!may_add_dict || add_dict) {
 					PyErr_SetString(PyExc_TypeError,
@@ -2179,7 +2179,7 @@ type_new(PyTypeObject *metatype, PyObject *args, PyObject *kwds)
 		for (i = j = 0; i < nslots; i++) {
 			char *s;
 			tmp = PyTuple_GET_ITEM(slots, i);
-			s = PyString_AS_STRING(tmp);
+			s = PyBytes_AS_STRING(tmp);
 			if ((add_dict && strcmp(s, "__dict__") == 0) ||
 			    (add_weak && strcmp(s, "__weakref__") == 0))
 				continue;
@@ -2272,7 +2272,7 @@ type_new(PyTypeObject *metatype, PyObject *args, PyObject *kwds)
 	type->tp_as_sequence = &et->as_sequence;
 	type->tp_as_mapping = &et->as_mapping;
 	type->tp_as_buffer = &et->as_buffer;
-	type->tp_name = PyString_AS_STRING(name);
+	type->tp_name = PyBytes_AS_STRING(name);
 
 	/* Set tp_base and tp_bases */
 	type->tp_bases = bases;
@@ -2305,14 +2305,14 @@ type_new(PyTypeObject *metatype, PyObject *args, PyObject *kwds)
 	*/
 	{
 		PyObject *doc = PyDict_GetItemString(dict, "__doc__");
-		if (doc != NULL && PyString_Check(doc)) {
-			const size_t n = (size_t)PyString_GET_SIZE(doc);
+		if (doc != NULL && PyBytes_Check(doc)) {
+			const size_t n = (size_t)PyBytes_GET_SIZE(doc);
 			char *tp_doc = (char *)PyObject_MALLOC(n+1);
 			if (tp_doc == NULL) {
 				Py_DECREF(type);
 				return NULL;
 			}
-			memcpy(tp_doc, PyString_AS_STRING(doc), n+1);
+			memcpy(tp_doc, PyBytes_AS_STRING(doc), n+1);
 			type->tp_doc = tp_doc;
 		}
 	}
@@ -2335,7 +2335,7 @@ type_new(PyTypeObject *metatype, PyObject *args, PyObject *kwds)
 	slotoffset = base->tp_basicsize;
 	if (slots != NULL) {
 		for (i = 0; i < nslots; i++, mp++) {
-			mp->name = PyString_AS_STRING(
+			mp->name = PyBytes_AS_STRING(
 				PyTuple_GET_ITEM(slots, i));
 			mp->type = T_OBJECT_EX;
 			mp->offset = slotoffset;
@@ -2536,7 +2536,7 @@ type_getattro(PyTypeObject *type, PyObject *name)
 	/* Give up */
 	PyErr_Format(PyExc_AttributeError,
 			 "type object '%.50s' has no attribute '%.400s'",
-			 type->tp_name, PyString_AS_STRING(name));
+			 type->tp_name, PyBytes_AS_STRING(name));
 	return NULL;
 }
 
@@ -2855,7 +2855,7 @@ object_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 		if (sorted_methods == NULL)
 			goto error;
 		if (comma == NULL) {
-			comma = PyString_InternFromString(", ");
+			comma = PyBytes_InternFromString(", ");
 			if (comma == NULL)
 				goto error;
 		}
@@ -2863,7 +2863,7 @@ object_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 					     "O",  sorted_methods);
 		if (joined == NULL)
 			goto error;
-		joined_str = PyString_AsString(joined);
+		joined_str = PyBytes_AsString(joined);
 		if (joined_str == NULL)
 			goto error;
 
@@ -2897,20 +2897,20 @@ object_repr(PyObject *self)
 	mod = type_module(type, NULL);
 	if (mod == NULL)
 		PyErr_Clear();
-	else if (!PyString_Check(mod)) {
+	else if (!PyBytes_Check(mod)) {
 		Py_DECREF(mod);
 		mod = NULL;
 	}
 	name = type_name(type, NULL);
 	if (name == NULL)
 		return NULL;
-	if (mod != NULL && strcmp(PyString_AS_STRING(mod), "__builtin__"))
-		rtn = PyString_FromFormat("<%s.%s object at %p>",
-					  PyString_AS_STRING(mod),
-					  PyString_AS_STRING(name),
+	if (mod != NULL && strcmp(PyBytes_AS_STRING(mod), "__builtin__"))
+		rtn = PyBytes_FromFormat("<%s.%s object at %p>",
+					  PyBytes_AS_STRING(mod),
+					  PyBytes_AS_STRING(name),
 					  self);
 	else
-		rtn = PyString_FromFormat("<%s object at %p>",
+		rtn = PyBytes_FromFormat("<%s object at %p>",
 					  type->tp_name, self);
 	Py_XDECREF(mod);
 	Py_DECREF(name);
@@ -3070,7 +3070,7 @@ import_copyreg(void)
 	static PyObject *copyreg_str;
 
 	if (!copyreg_str) {
-		copyreg_str = PyString_InternFromString("copy_reg");
+		copyreg_str = PyBytes_InternFromString("copy_reg");
 		if (copyreg_str == NULL)
 			return NULL;
 	}
@@ -3376,7 +3376,7 @@ object_format(PyObject *self, PyObject *args)
                 return NULL;
 	if (PyUnicode_Check(format_spec)) {
 	        self_as_str = PyObject_Unicode(self);
-	} else if (PyString_Check(format_spec)) {
+	} else if (PyBytes_Check(format_spec)) {
 	        self_as_str = PyObject_Str(self);
 	} else {
 	        PyErr_SetString(PyExc_TypeError, "argument to __format__ must be unicode or str");
@@ -3619,7 +3619,7 @@ inherit_special(PyTypeObject *type, PyTypeObject *base)
 		type->tp_flags |= Py_TPFLAGS_INT_SUBCLASS;
 	else if (PyType_IsSubtype(base, &PyLong_Type))
 		type->tp_flags |= Py_TPFLAGS_LONG_SUBCLASS;
-	else if (PyType_IsSubtype(base, &PyString_Type))
+	else if (PyType_IsSubtype(base, &PyBytes_Type))
 		type->tp_flags |= Py_TPFLAGS_STRING_SUBCLASS;
 #ifdef Py_USING_UNICODE
 	else if (PyType_IsSubtype(base, &PyUnicode_Type))
@@ -3958,7 +3958,7 @@ PyType_Ready(PyTypeObject *type)
 	 */
 	if (PyDict_GetItemString(type->tp_dict, "__doc__") == NULL) {
 		if (type->tp_doc != NULL) {
-			PyObject *doc = PyString_FromString(type->tp_doc);
+			PyObject *doc = PyBytes_FromString(type->tp_doc);
 			if (doc == NULL)
 				goto error;
 			PyDict_SetItemString(type->tp_dict, "__doc__", doc);
@@ -4846,7 +4846,7 @@ slot_sq_item(PyObject *self, Py_ssize_t i)
 	descrgetfunc f;
 
 	if (getitem_str == NULL) {
-		getitem_str = PyString_InternFromString("__getitem__");
+		getitem_str = PyBytes_InternFromString("__getitem__");
 		if (getitem_str == NULL)
 			return NULL;
 	}
@@ -5214,7 +5214,7 @@ slot_tp_repr(PyObject *self)
 		return res;
 	}
 	PyErr_Clear();
-	return PyString_FromFormat("<%s object at %p>",
+	return PyBytes_FromFormat("<%s object at %p>",
 				   Py_TYPE(self)->tp_name, self);
 }
 
@@ -5322,13 +5322,13 @@ slot_tp_getattr_hook(PyObject *self, PyObject *name)
 	static PyObject *getattr_str = NULL;
 
 	if (getattr_str == NULL) {
-		getattr_str = PyString_InternFromString("__getattr__");
+		getattr_str = PyBytes_InternFromString("__getattr__");
 		if (getattr_str == NULL)
 			return NULL;
 	}
 	if (getattribute_str == NULL) {
 		getattribute_str =
-			PyString_InternFromString("__getattribute__");
+			PyBytes_InternFromString("__getattribute__");
 		if (getattribute_str == NULL)
 			return NULL;
 	}
@@ -5469,7 +5469,7 @@ slot_tp_descr_get(PyObject *self, PyObject *obj, PyObject *type)
 	static PyObject *get_str = NULL;
 
 	if (get_str == NULL) {
-		get_str = PyString_InternFromString("__get__");
+		get_str = PyBytes_InternFromString("__get__");
 		if (get_str == NULL)
 			return NULL;
 	}
@@ -5539,7 +5539,7 @@ slot_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 	Py_ssize_t i, n;
 
 	if (new_str == NULL) {
-		new_str = PyString_InternFromString("__new__");
+		new_str = PyBytes_InternFromString("__new__");
 		if (new_str == NULL)
 			return NULL;
 	}
@@ -6069,7 +6069,7 @@ init_slotdefs(void)
 	if (initialized)
 		return;
 	for (p = slotdefs; p->name; p++) {
-		p->name_strobj = PyString_InternFromString(p->name);
+		p->name_strobj = PyBytes_InternFromString(p->name);
 		if (!p->name_strobj)
 			Py_FatalError("Out of memory interning slotdef names");
 	}
@@ -6284,12 +6284,12 @@ super_repr(PyObject *self)
 	superobject *su = (superobject *)self;
 
 	if (su->obj_type)
-		return PyString_FromFormat(
+		return PyBytes_FromFormat(
 			"<super: <class '%s'>, <%s object>>",
 			su->type ? su->type->tp_name : "NULL",
 			su->obj_type->tp_name);
 	else
-		return PyString_FromFormat(
+		return PyBytes_FromFormat(
 			"<super: <class '%s'>, NULL>",
 			su->type ? su->type->tp_name : "NULL");
 }
@@ -6303,9 +6303,9 @@ super_getattro(PyObject *self, PyObject *name)
 	if (!skip) {
 		/* We want __class__ to return the class of the super object
 		   (i.e. super, or a subclass), not the class of su->obj. */
-		skip = (PyString_Check(name) &&
-			PyString_GET_SIZE(name) == 9 &&
-			strcmp(PyString_AS_STRING(name), "__class__") == 0);
+		skip = (PyBytes_Check(name) &&
+			PyBytes_GET_SIZE(name) == 9 &&
+			strcmp(PyBytes_AS_STRING(name), "__class__") == 0);
 	}
 
 	if (!skip) {
@@ -6397,7 +6397,7 @@ supercheck(PyTypeObject *type, PyObject *obj)
 		PyObject *class_attr;
 
 		if (class_str == NULL) {
-			class_str = PyString_FromString("__class__");
+			class_str = PyBytes_FromString("__class__");
 			if (class_str == NULL)
 				return NULL;
 		}
diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c
index c008bd6..7af560c 100644
--- a/Objects/unicodeobject.c
+++ b/Objects/unicodeobject.c
@@ -1080,9 +1080,9 @@ PyObject *PyUnicode_FromEncodedObject(register PyObject *obj,
 #endif
 
     /* Coerce object */
-    if (PyString_Check(obj)) {
-	    s = PyString_AS_STRING(obj);
-	    len = PyString_GET_SIZE(obj);
+    if (PyBytes_Check(obj)) {
+	    s = PyBytes_AS_STRING(obj);
+	    len = PyBytes_GET_SIZE(obj);
     }
     else if (PyByteArray_Check(obj)) {
         /* Python 2.x specific */
@@ -1254,7 +1254,7 @@ PyObject *PyUnicode_AsEncodedString(PyObject *unicode,
     v = PyCodec_Encode(unicode, encoding, errors);
     if (v == NULL)
         goto onError;
-    if (!PyString_Check(v)) {
+    if (!PyBytes_Check(v)) {
         PyErr_Format(PyExc_TypeError,
                      "encoder did not return a string object (type=%.400s)",
                      Py_TYPE(v)->tp_name);
@@ -1654,13 +1654,13 @@ PyObject *PyUnicode_EncodeUTF7(const Py_UNICODE *s,
     char * start;
 
     if (size == 0)
-		return PyString_FromStringAndSize(NULL, 0);
+		return PyBytes_FromStringAndSize(NULL, 0);
 
-    v = PyString_FromStringAndSize(NULL, cbAllocated);
+    v = PyBytes_FromStringAndSize(NULL, cbAllocated);
     if (v == NULL)
         return NULL;
 
-    start = out = PyString_AS_STRING(v);
+    start = out = PyBytes_AS_STRING(v);
     for (;i < size; ++i) {
         Py_UNICODE ch = s[i];
 
@@ -1726,7 +1726,7 @@ PyObject *PyUnicode_EncodeUTF7(const Py_UNICODE *s,
         *out++ = '-';
     }
 
-    _PyString_Resize(&v, out - start);
+    _PyBytes_Resize(&v, out - start);
     return v;
 }
 
@@ -1991,10 +1991,10 @@ PyUnicode_EncodeUTF8(const Py_UNICODE *s,
         nallocated = size * 4;
         if (nallocated / 4 != size)  /* overflow! */
             return PyErr_NoMemory();
-        v = PyString_FromStringAndSize(NULL, nallocated);
+        v = PyBytes_FromStringAndSize(NULL, nallocated);
         if (v == NULL)
             return NULL;
-        p = PyString_AS_STRING(v);
+        p = PyBytes_AS_STRING(v);
     }
 
     for (i = 0; i < size;) {
@@ -2042,13 +2042,13 @@ encodeUCS4:
         /* This was stack allocated. */
         nneeded = p - stackbuf;
         assert(nneeded <= nallocated);
-        v = PyString_FromStringAndSize(stackbuf, nneeded);
+        v = PyBytes_FromStringAndSize(stackbuf, nneeded);
     }
     else {
     	/* Cut back to size actually needed. */
-        nneeded = p - PyString_AS_STRING(v);
+        nneeded = p - PyBytes_AS_STRING(v);
         assert(nneeded <= nallocated);
-        _PyString_Resize(&v, nneeded);
+        _PyBytes_Resize(&v, nneeded);
     }
     return v;
 
@@ -2276,12 +2276,12 @@ PyUnicode_EncodeUTF32(const Py_UNICODE *s,
 	    0xDC00 <= s[i+1] && s[i+1] <= 0xDFFF)
 	    pairs++;
 #endif
-    v = PyString_FromStringAndSize(NULL,
+    v = PyBytes_FromStringAndSize(NULL,
 		  4 * (size - pairs + (byteorder == 0)));
     if (v == NULL)
         return NULL;
 
-    p = (unsigned char *)PyString_AS_STRING(v);
+    p = (unsigned char *)PyBytes_AS_STRING(v);
     if (byteorder == 0)
 	STORECHAR(0xFEFF);
     if (size == 0)
@@ -2541,12 +2541,12 @@ PyUnicode_EncodeUTF16(const Py_UNICODE *s,
 	if (s[i] >= 0x10000)
 	    pairs++;
 #endif
-    v = PyString_FromStringAndSize(NULL,
+    v = PyBytes_FromStringAndSize(NULL,
 		  2 * (size + pairs + (byteorder == 0)));
     if (v == NULL)
         return NULL;
 
-    p = (unsigned char *)PyString_AS_STRING(v);
+    p = (unsigned char *)PyBytes_AS_STRING(v);
     if (byteorder == 0)
 	STORECHAR(0xFEFF);
     if (size == 0)
@@ -2889,7 +2889,7 @@ PyObject *unicodeescape_string(const Py_UNICODE *s,
        escape.
     */
 
-    repr = PyString_FromStringAndSize(NULL,
+    repr = PyBytes_FromStringAndSize(NULL,
         2
 #ifdef Py_UNICODE_WIDE
         + 10*size
@@ -2900,7 +2900,7 @@ PyObject *unicodeescape_string(const Py_UNICODE *s,
     if (repr == NULL)
         return NULL;
 
-    p = PyString_AS_STRING(repr);
+    p = PyBytes_AS_STRING(repr);
 
     if (quotes) {
         *p++ = 'u';
@@ -2912,7 +2912,7 @@ PyObject *unicodeescape_string(const Py_UNICODE *s,
 
         /* Escape quotes and backslashes */
         if ((quotes &&
-	     ch == (Py_UNICODE) PyString_AS_STRING(repr)[1]) || ch == '\\') {
+	     ch == (Py_UNICODE) PyBytes_AS_STRING(repr)[1]) || ch == '\\') {
             *p++ = '\\';
             *p++ = (char) ch;
 	    continue;
@@ -2998,10 +2998,10 @@ PyObject *unicodeescape_string(const Py_UNICODE *s,
             *p++ = (char) ch;
     }
     if (quotes)
-        *p++ = PyString_AS_STRING(repr)[1];
+        *p++ = PyBytes_AS_STRING(repr)[1];
 
     *p = '\0';
-    _PyString_Resize(&repr, p - PyString_AS_STRING(repr));
+    _PyBytes_Resize(&repr, p - PyBytes_AS_STRING(repr));
     return repr;
 }
 
@@ -3150,16 +3150,16 @@ PyObject *PyUnicode_EncodeRawUnicodeEscape(const Py_UNICODE *s,
     static const char *hexdigit = "0123456789abcdef";
 
 #ifdef Py_UNICODE_WIDE
-    repr = PyString_FromStringAndSize(NULL, 10 * size);
+    repr = PyBytes_FromStringAndSize(NULL, 10 * size);
 #else
-    repr = PyString_FromStringAndSize(NULL, 6 * size);
+    repr = PyBytes_FromStringAndSize(NULL, 6 * size);
 #endif
     if (repr == NULL)
         return NULL;
     if (size == 0)
 	return repr;
 
-    p = q = PyString_AS_STRING(repr);
+    p = q = PyBytes_AS_STRING(repr);
     while (size-- > 0) {
         Py_UNICODE ch = *s++;
 #ifdef Py_UNICODE_WIDE
@@ -3218,7 +3218,7 @@ PyObject *PyUnicode_EncodeRawUnicodeEscape(const Py_UNICODE *s,
             *p++ = (char) ch;
     }
     *p = '\0';
-    _PyString_Resize(&repr, p - q);
+    _PyBytes_Resize(&repr, p - q);
     return repr;
 }
 
@@ -3458,12 +3458,12 @@ static PyObject *unicode_encode_ucs1(const Py_UNICODE *p,
 
     /* allocate enough for a simple encoding without
        replacements, if we need more, we'll resize */
-    res = PyString_FromStringAndSize(NULL, size);
+    res = PyBytes_FromStringAndSize(NULL, size);
     if (res == NULL)
         goto onError;
     if (size == 0)
 	return res;
-    str = PyString_AS_STRING(res);
+    str = PyBytes_AS_STRING(res);
     ressize = size;
 
     while (p<endp) {
@@ -3513,7 +3513,7 @@ static PyObject *unicode_encode_ucs1(const Py_UNICODE *p,
 		    p = collend;
 		    break;
 		case 4: /* xmlcharrefreplace */
-		    respos = str-PyString_AS_STRING(res);
+		    respos = str-PyBytes_AS_STRING(res);
 		    /* determine replacement size (temporarily (mis)uses p) */
 		    for (p = collstart, repsize = 0; p < collend; ++p) {
 			if (*p<10)
@@ -3540,9 +3540,9 @@ static PyObject *unicode_encode_ucs1(const Py_UNICODE *p,
 		    if (requiredsize > ressize) {
 			if (requiredsize<2*ressize)
 			    requiredsize = 2*ressize;
-			if (_PyString_Resize(&res, requiredsize))
+			if (_PyBytes_Resize(&res, requiredsize))
 			    goto onError;
-			str = PyString_AS_STRING(res) + respos;
+			str = PyBytes_AS_STRING(res) + respos;
 			ressize = requiredsize;
 		    }
 		    /* generate replacement (temporarily (mis)uses p) */
@@ -3560,17 +3560,17 @@ static PyObject *unicode_encode_ucs1(const Py_UNICODE *p,
 		    /* need more space? (at least enough for what we
 		       have+the replacement+the rest of the string, so
 		       we won't have to check space for encodable characters) */
-		    respos = str-PyString_AS_STRING(res);
+		    respos = str-PyBytes_AS_STRING(res);
 		    repsize = PyUnicode_GET_SIZE(repunicode);
 		    requiredsize = respos+repsize+(endp-collend);
 		    if (requiredsize > ressize) {
 			if (requiredsize<2*ressize)
 			    requiredsize = 2*ressize;
-			if (_PyString_Resize(&res, requiredsize)) {
+			if (_PyBytes_Resize(&res, requiredsize)) {
 			    Py_DECREF(repunicode);
 			    goto onError;
 			}
-			str = PyString_AS_STRING(res) + respos;
+			str = PyBytes_AS_STRING(res) + respos;
 			ressize = requiredsize;
 		    }
 		    /* check if there is anything unencodable in the replacement
@@ -3591,10 +3591,10 @@ static PyObject *unicode_encode_ucs1(const Py_UNICODE *p,
 	}
     }
     /* Resize if we allocated to much */
-    respos = str-PyString_AS_STRING(res);
+    respos = str-PyBytes_AS_STRING(res);
     if (respos<ressize)
        /* If this falls res will be NULL */
-	_PyString_Resize(&res, respos);
+	_PyBytes_Resize(&res, respos);
     Py_XDECREF(errorHandler);
     Py_XDECREF(exc);
     return res;
@@ -3671,7 +3671,7 @@ PyObject *PyUnicode_DecodeASCII(const char *s,
 		goto onError;
 	}
     }
-    if (p - PyUnicode_AS_UNICODE(v) < PyString_GET_SIZE(v))
+    if (p - PyUnicode_AS_UNICODE(v) < PyBytes_GET_SIZE(v))
 	if (_PyUnicode_Resize(&v, p - PyUnicode_AS_UNICODE(v)) < 0)
 	    goto onError;
     Py_XDECREF(errorHandler);
@@ -3849,20 +3849,20 @@ static int encode_mbcs(PyObject **repr,
 
     if (*repr == NULL) {
 	/* Create string object */
-	*repr = PyString_FromStringAndSize(NULL, mbcssize);
+	*repr = PyBytes_FromStringAndSize(NULL, mbcssize);
 	if (*repr == NULL)
 	    return -1;
     }
     else {
 	/* Extend string object */
-	n = PyString_Size(*repr);
-	if (_PyString_Resize(repr, n + mbcssize) < 0)
+	n = PyBytes_Size(*repr);
+	if (_PyBytes_Resize(repr, n + mbcssize) < 0)
 	    return -1;
     }
 
     /* Do the conversion */
     if (size > 0) {
-	char *s = PyString_AS_STRING(*repr) + n;
+	char *s = PyBytes_AS_STRING(*repr) + n;
 	if (0 == WideCharToMultiByte(CP_ACP, 0, p, size, s, mbcssize, NULL, NULL)) {
 	    PyErr_SetFromWindowsErrWithFilename(0, NULL);
 	    return -1;
@@ -4329,7 +4329,7 @@ static PyObject *charmapencode_lookup(Py_UNICODE c, PyObject *mapping)
 	}
 	return x;
     }
-    else if (PyString_Check(x))
+    else if (PyBytes_Check(x))
 	return x;
     else {
 	/* wrong return value */
@@ -4343,11 +4343,11 @@ static PyObject *charmapencode_lookup(Py_UNICODE c, PyObject *mapping)
 static int
 charmapencode_resize(PyObject **outobj, Py_ssize_t *outpos, Py_ssize_t requiredsize)
 {
-	Py_ssize_t outsize = PyString_GET_SIZE(*outobj);
+	Py_ssize_t outsize = PyBytes_GET_SIZE(*outobj);
 	/* exponentially overallocate to minimize reallocations */
 	if (requiredsize < 2*outsize)
 	    requiredsize = 2*outsize;
-	if (_PyString_Resize(outobj, requiredsize)) {
+	if (_PyBytes_Resize(outobj, requiredsize)) {
 	    return 0;
 	}
 	return 1;
@@ -4368,7 +4368,7 @@ charmapencode_result charmapencode_output(Py_UNICODE c, PyObject *mapping,
 {
     PyObject *rep;
     char *outstart;
-    Py_ssize_t outsize = PyString_GET_SIZE(*outobj);
+    Py_ssize_t outsize = PyBytes_GET_SIZE(*outobj);
 
     if (Py_TYPE(mapping) == &EncodingMapType) {
         int res = encoding_map_lookup(c, mapping);
@@ -4378,7 +4378,7 @@ charmapencode_result charmapencode_output(Py_UNICODE c, PyObject *mapping,
 	if (outsize<requiredsize) 
 	    if (!charmapencode_resize(outobj, outpos, requiredsize))
 		return enc_EXCEPTION;
-        outstart = PyString_AS_STRING(*outobj);
+        outstart = PyBytes_AS_STRING(*outobj);
 	outstart[(*outpos)++] = (char)res;
 	return enc_SUCCESS;
     }
@@ -4397,19 +4397,19 @@ charmapencode_result charmapencode_output(Py_UNICODE c, PyObject *mapping,
 		    Py_DECREF(rep);
 		    return enc_EXCEPTION;
 		}
-            outstart = PyString_AS_STRING(*outobj);
+            outstart = PyBytes_AS_STRING(*outobj);
 	    outstart[(*outpos)++] = (char)PyInt_AS_LONG(rep);
 	}
 	else {
-	    const char *repchars = PyString_AS_STRING(rep);
-	    Py_ssize_t repsize = PyString_GET_SIZE(rep);
+	    const char *repchars = PyBytes_AS_STRING(rep);
+	    Py_ssize_t repsize = PyBytes_GET_SIZE(rep);
 	    Py_ssize_t requiredsize = *outpos+repsize;
 	    if (outsize<requiredsize)
 		if (!charmapencode_resize(outobj, outpos, requiredsize)) {
 		    Py_DECREF(rep);
 		    return enc_EXCEPTION;
 		}
-            outstart = PyString_AS_STRING(*outobj);
+            outstart = PyBytes_AS_STRING(*outobj);
 	    memcpy(outstart + *outpos, repchars, repsize);
 	    *outpos += repsize;
 	}
@@ -4560,7 +4560,7 @@ PyObject *PyUnicode_EncodeCharmap(const Py_UNICODE *p,
 
     /* allocate enough for a simple encoding without
        replacements, if we need more, we'll resize */
-    res = PyString_FromStringAndSize(NULL, size);
+    res = PyBytes_FromStringAndSize(NULL, size);
     if (res == NULL)
         goto onError;
     if (size == 0)
@@ -4585,8 +4585,8 @@ PyObject *PyUnicode_EncodeCharmap(const Py_UNICODE *p,
     }
 
     /* Resize if we allocated to much */
-    if (respos<PyString_GET_SIZE(res)) {
-	if (_PyString_Resize(&res, respos))
+    if (respos<PyBytes_GET_SIZE(res)) {
+	if (_PyBytes_Resize(&res, respos))
 	    goto onError;
     }
     Py_XDECREF(exc);
@@ -5484,7 +5484,7 @@ PyUnicode_Join(PyObject *separator, PyObject *seq)
 
 	item = PySequence_Fast_GET_ITEM(fseq, i);
 	/* Convert item to Unicode. */
-	if (! PyUnicode_Check(item) && ! PyString_Check(item)) {
+	if (! PyUnicode_Check(item) && ! PyBytes_Check(item)) {
 	    PyErr_Format(PyExc_TypeError,
 			 "sequence item %zd: expected string or Unicode,"
 			 " %.80s found",
@@ -6488,7 +6488,7 @@ unicode_encode(PyUnicodeObject *self, PyObject *args)
     v = PyUnicode_AsEncodedObject((PyObject *)self, encoding, errors);
     if (v == NULL)
         goto onError;
-    if (!PyString_Check(v) && !PyUnicode_Check(v)) {
+    if (!PyBytes_Check(v) && !PyUnicode_Check(v)) {
         PyErr_Format(PyExc_TypeError,
                      "encoder did not return a string/unicode object "
                      "(type=%.400s)",
@@ -6524,7 +6524,7 @@ unicode_decode(PyUnicodeObject *self, PyObject *args)
     v = PyUnicode_AsDecodedObject((PyObject *)self, encoding, errors);
     if (v == NULL)
         goto onError;
-    if (!PyString_Check(v) && !PyUnicode_Check(v)) {
+    if (!PyBytes_Check(v) && !PyUnicode_Check(v)) {
         PyErr_Format(PyExc_TypeError,
                      "decoder did not return a string/unicode object "
                      "(type=%.400s)",
@@ -7154,7 +7154,7 @@ do_argstrip(PyUnicodeObject *self, int striptype, PyObject *args)
 	if (sep != NULL && sep != Py_None) {
 		if (PyUnicode_Check(sep))
 			return _PyUnicode_XStrip(self, striptype, sep);
-		else if (PyString_Check(sep)) {
+		else if (PyBytes_Check(sep)) {
 			PyObject *res;
 			sep = PyUnicode_FromObject(sep);
 			if (sep==NULL)
@@ -8071,8 +8071,8 @@ unicode_buffer_getcharbuf(PyUnicodeObject *self,
     str = _PyUnicode_AsDefaultEncodedString((PyObject *)self, NULL);
     if (str == NULL)
 	return -1;
-    *ptr = (void *) PyString_AS_STRING(str);
-    return PyString_GET_SIZE(str);
+    *ptr = (void *) PyBytes_AS_STRING(str);
+    return PyBytes_GET_SIZE(str);
 }
 
 /* Helpers for PyUnicode_Format() */
@@ -8191,7 +8191,7 @@ formatlong(PyObject *val, int flags, int prec, int type)
 	PyObject *str; /* temporary string object. */
 	PyUnicodeObject *result;
 
-	str = _PyString_FormatLong(val, flags, prec, type, &buf, &len);
+	str = _PyBytes_FormatLong(val, flags, prec, type, &buf, &len);
 	if (!str)
 		return NULL;
 	result = _PyUnicode_New(len);
@@ -8293,10 +8293,10 @@ formatchar(Py_UNICODE *buf,
 	buf[0] = PyUnicode_AS_UNICODE(v)[0];
     }
 
-    else if (PyString_Check(v)) {
-	if (PyString_GET_SIZE(v) != 1)
+    else if (PyBytes_Check(v)) {
+	if (PyBytes_GET_SIZE(v) != 1)
 	    goto onError;
-	buf[0] = (Py_UNICODE)PyString_AS_STRING(v)[0];
+	buf[0] = (Py_UNICODE)PyBytes_AS_STRING(v)[0];
     }
 
     else {
@@ -8579,10 +8579,10 @@ PyObject *PyUnicode_Format(PyObject *format,
 			goto onError;
                     if (PyUnicode_Check(temp))
                         /* nothing to do */;
-                    else if (PyString_Check(temp)) {
+                    else if (PyBytes_Check(temp)) {
                         /* convert to string to Unicode */
-		        unicode = PyUnicode_Decode(PyString_AS_STRING(temp),
-						   PyString_GET_SIZE(temp),
+		        unicode = PyUnicode_Decode(PyBytes_AS_STRING(temp),
+						   PyBytes_GET_SIZE(temp),
 						   NULL,
 						   "strict");
 		        Py_DECREF(temp);
diff --git a/Objects/weakrefobject.c b/Objects/weakrefobject.c
index 1aee5a5..2899bc70 100644
--- a/Objects/weakrefobject.c
+++ b/Objects/weakrefobject.c
@@ -166,8 +166,8 @@ weakref_repr(PyWeakReference *self)
 						   "__name__");
 	if (nameobj == NULL)
 		PyErr_Clear();
-	else if (PyString_Check(nameobj))
-		name = PyString_AS_STRING(nameobj);
+	else if (PyBytes_Check(nameobj))
+		name = PyBytes_AS_STRING(nameobj);
         PyOS_snprintf(buffer, sizeof(buffer),
 		      name ? "<weakref at %p; to '%.50s' at %p (%s)>"
 		           : "<weakref at %p; to '%.50s' at %p>",
@@ -177,7 +177,7 @@ weakref_repr(PyWeakReference *self)
 		      name);
 	Py_XDECREF(nameobj);
     }
-    return PyString_FromString(buffer);
+    return PyBytes_FromString(buffer);
 }
 
 /* Weak references only support equality, not ordering. Two weak references
@@ -448,7 +448,7 @@ proxy_repr(PyWeakReference *proxy)
 		  "<weakproxy at %p to %.100s at %p>", proxy,
 		  Py_TYPE(PyWeakref_GET_OBJECT(proxy))->tp_name,
 		  PyWeakref_GET_OBJECT(proxy));
-    return PyString_FromString(buf);
+    return PyBytes_FromString(buf);
 }