python
diff --git a/‎Lib/ntpath.py
Lines changed: 31 additions & 31 deletions b/‎Lib/ntpath.py
Lines changed: 31 additions & 31 deletions
diff --git a/‎Lib/posixpath.py
Lines changed: 15 additions & 15 deletions b/‎Lib/posixpath.py
Lines changed: 15 additions & 15 deletions
@@ -110,34 +110,34 @@ def join(path, *paths):
     try:
         if not paths:
             path[:0] + sep  #23780: Ensure compatible data type even if p is null.
-        result_drive, result_root, result_tail = splitroot(path)
+        result_drive, result_root, result_path = splitroot(path)
         for p in map(os.fspath, paths):
-            p_drive, p_root, p_tail = splitroot(p)
+            p_drive, p_root, p_path = splitroot(p)
             if p_root:
                 # Second path is absolute
                 if p_drive or not result_drive:
                     result_drive = p_drive
                 result_root = p_root
-                result_tail = p_tail
+                result_path = p_path
                 continue
             elif p_drive and p_drive != result_drive:
                 if p_drive.lower() != result_drive.lower():
                     # Different drives => ignore the first path entirely
                     result_drive = p_drive
                     result_root = p_root
-                    result_tail = p_tail
+                    result_path = p_path
                     continue
                 # Same drive in different case
                 result_drive = p_drive
             # Second path is relative to the first
-            if result_tail and result_tail[-1] not in seps:
-                result_tail = result_tail + sep
-            result_tail = result_tail + p_tail
+            if result_path and result_path[-1] not in seps:
+                result_path = result_path + sep
+            result_path = result_path + p_path
         ## add separator between UNC and non-absolute path
-        if (result_tail and not result_root and
+        if (result_path and not result_root and
             result_drive and result_drive[-1] not in colon + seps):
-            return result_drive + sep + result_tail
-        return result_drive + result_root + result_tail
+            return result_drive + sep + result_path
+        return result_drive + result_root + result_path
     except (TypeError, AttributeError, BytesWarning):
         genericpath._check_arg_types('join', path, *paths)
         raise
@@ -233,13 +233,13 @@ def split(p):
     Either part may be empty."""
     p = os.fspath(p)
     seps = _get_bothseps(p)
-    drive, root, tail = splitroot(p)
+    d, r, p = splitroot(p)
     # set i to index beyond p's last slash
-    i = len(tail)
-    while i and tail[i-1] not in seps:
+    i = len(p)
+    while i and p[i-1] not in seps:
         i -= 1
-    head, tail = tail[:i], tail[i:]  # now tail has no slashes
-    return drive + root + head.rstrip(seps), tail
+    head, p = p[:i], p[i:]  # now tail has no slashes
+    return d + r + head.rstrip(seps), p
 
 
 # Split a path in root and extension.
@@ -307,10 +307,10 @@ def ismount(path):
     path = os.fspath(path)
     seps = _get_bothseps(path)
     path = abspath(path)
-    drive, root, tail = splitroot(path)
+    drive, root, rest = splitroot(path)
     if drive and drive[0] in seps:
-        return not tail
-    if root and not tail:
+        return not rest
+    if root and not rest:
         return True
     if not _getvolumepathname:
         return False
@@ -552,9 +552,9 @@ def normpath(path):
             curdir = '.'
             pardir = '..'
         path = path.replace(altsep, sep)
-        drive, root, tail = splitroot(path)
+        drive, root, path = splitroot(path)
         prefix = drive + root
-        comps = tail.split(sep)
+        comps = path.split(sep)
         i = 0
         while i < len(comps):
             if not comps[i] or comps[i] == curdir:
@@ -796,14 +796,14 @@ def relpath(path, start=None):
     try:
         start_abs = abspath(normpath(start))
         path_abs = abspath(normpath(path))
-        start_drive, _, start_tail = splitroot(start_abs)
-        path_drive, _, path_tail = splitroot(path_abs)
+        start_drive, _, start_rest = splitroot(start_abs)
+        path_drive, _, path_rest = splitroot(path_abs)
         if normcase(start_drive) != normcase(path_drive):
             raise ValueError("path is on mount %r, start on mount %r" % (
                 path_drive, start_drive))
 
-        start_list = [x for x in start_tail.split(sep) if x]
-        path_list = [x for x in path_tail.split(sep) if x]
+        start_list = [x for x in start_rest.split(sep) if x]
+        path_list = [x for x in path_rest.split(sep) if x]
         # Work out how much of the filepath is shared by start and path.
         i = 0
         for e1, e2 in zip(start_list, path_list):
@@ -847,23 +847,23 @@ def commonpath(paths):
         curdir = '.'
 
     try:
-        rootsplits = [splitroot(p.replace(altsep, sep).lower()) for p in paths]
+        drivesplits = [splitroot(p.replace(altsep, sep).lower()) for p in paths]
 
         # Check that all drive letters or UNC paths match. The check is made
         # only now otherwise type errors for mixing strings and bytes would not
         # be caught.
-        if len({drive for drive, _, _ in rootsplits}) != 1:
+        if len({d for d, _, _ in drivesplits}) != 1:
             raise ValueError("Paths don't have the same drive")
 
-        if len({root for _, root, _ in rootsplits}) != 1:
+        if len({r for _, r, _ in drivesplits}) != 1:
             raise ValueError("Can't mix absolute and relative paths")
 
-        drive, root, tail = splitroot(paths[0].replace(altsep, sep))
-        common = [c for c in tail.split(sep) if c and c != curdir]
+        drive, root, path = splitroot(paths[0].replace(altsep, sep))
+        common = [c for c in path.split(sep) if c and c != curdir]
 
         split_paths = [
-            [c for c in tail.split(sep) if c and c != curdir]
-            for _, _, tail in rootsplits
+            [c for c in p.split(sep) if c and c != curdir]
+            for _, _, p in drivesplits
         ]
         s1 = min(split_paths)
         s2 = max(split_paths)
 
@@ -333,25 +333,25 @@ def _normpath_fallback(path):
     path = os.fspath(path)
     if isinstance(path, bytes):
         sep = b'/'
-        curdir = b'.'
-        pardir = b'..'
+        dot = b'.'
+        dotdot = b'..'
     else:
         sep = '/'
-        curdir = '.'
-        pardir = '..'
+        dot = '.'
+        dotdot = '..'
     if not path:
-        return curdir
-    _, root, tail = splitroot(path)
-    comps = []
-    for comp in tail.split(sep):
-        if not comp or comp == curdir:
+        return dot
+    _, initial_slashes, path = splitroot(path)
+    new_comps = []
+    for comp in path.split(sep):
+        if not comp or comp == dot:
             continue
-        if (comp != pardir or (not root and not comps) or
-             (comps and comps[-1] == pardir)):
-            comps.append(comp)
-        elif comps:
-            comps.pop()
-    return (root + sep.join(comps)) or curdir
+        if (comp != dotdot or (not initial_slashes and not new_comps) or
+             (new_comps and new_comps[-1] == dotdot)):
+            new_comps.append(comp)
+        elif new_comps:
+            new_comps.pop()
+    return (initial_slashes + sep.join(new_comps)) or dot
 
 try:
     from posix import _path_normpath