path at the end.
340173
int insertPath(int geometry, int before_path) {
		int prev = -1;

		if (before_path != -1) {
			if (geometry != getGeometryFromPath(before_path))
				throw GeometryException.GeometryInternalError();

			prev = getPrevPath(before_path);
		} else
			prev = getLastPath(geometry);

		int newpath = newPath_(geometry);
		if (before_path != -1)
			setPrevPath_(before_path, newpath);

		setNextPath_(newpath, before_path);
		setPrevPath_(newpath, prev);
		if (prev != -1)
			setNextPath_(prev, newpath);
		else
			setFirstPath_(geometry, newpath);

		if (before_path == -1)
			setLastPath_(geometry, newpath);

		setGeometryPathCount_(geometry, getPathCount(geometry) + 1);
		return newpath;
	}
1139224
public static void path(@NotNull String path, @NotNull EndpointGroup endpointGroup) {
        path = path.startsWith("/") ? path : "/" + path;
        pathDeque.addLast(path);
        endpointGroup.addEndpoints();
        pathDeque.removeLast();
    }
92781
function (path, basePath) {
        if (!basePath || path.match(/^\//)) {
            return path;
        }
        var pathParts = path.split('/');
        var basePathParts = basePath.split('/');

        var item = pathParts[0];
        while(item === '.' || item === '..') {
            if (item === '..') {
                basePathParts.pop();
            }
            pathParts.shift();
            item = pathParts[0];
        }
        return basePathParts.join('/') + '/' + pathParts.join('/');
    }
966213
def move_to_end(self, key, last=True):
        '''

        '''
        link = self.__map[key]
        link_prev = link.prev
        link_next = link.next
        link_prev.next = link_next
        link_next.prev = link_prev
        root = self.__root
        if last:
            last = root.prev
            link.prev = last
            link.next = root
            last.next = root.prev = link
        else:
            first = root.next
            link.prev = root
            link.next = first
            root.next = first.prev = link
1184921
function deletePath(obj, path) {
	var cur = obj;
	var parts = path.split('.');
	var i;
	for (i = 0; i < parts.length; i++) {
		if (i === parts.length - 1) {
			delete cur[parts[i]];
		} else {
			if (isScalar(cur[parts[i]])) {
				return obj;
			}
			cur = cur[parts[i]];
		}
	}
	return obj;
}
407497
public void rmLittleSinglePath() {
		int maxTo = -1;
		Term temp = null;
		for (int i = 0; i < terms.length; i++) {
			if (terms[i] == null) {
				continue;
			}
			maxTo = terms[i].toValue();
			if (maxTo - i == 1 || i + 1 == terms.length) {
				continue;
			}
			for (int j = i; j < maxTo; j++) {
				temp = terms[j];
				if (temp != null && temp.toValue() <= maxTo && temp.getName().length() == 1) {
					terms[j] = null;
				}
			}
		}
	}
128994
function followPath(path, loop) {
        loop = !!loop;

        const wayPoint = path[pathIndex];
        if (!wayPoint) {
            pathIndex = 0;
            return boid;
        }
        if (position.distanceSq(wayPoint) < pathThresholdSq) {
            if (pathIndex >= path.length - 1) {
                if (loop) {
                    pathIndex = 0;
                }
            } else {
                pathIndex++;
            }
        }
        if (pathIndex >= path.length - 1 && !loop) {
            arrive(wayPoint);
        } else {
            seek(wayPoint);
        }
        return boid;
    }
327442
function path() {
  var p = _.random(1);
  var words = choose(above);

  words += fragment(s[p], (choose(trans)+s[(p+1)%2]));

  words += ['', 'the', choose(below)].join(' ') + choose(s) + ".";
  return words;
}
130021
def image_absoulte_path(self, url, image):
        """"""
        if not re.match(re_http, image):
            topimage = urljoin(url, image)
            return topimage
        return image
214502
def path_join(*args):
    """"""
    return SEP.join((x for x in args if x not in (None, ''))).strip(SEP)
668646
static private boolean isAncestorPath(String x, String y) {
    if (!y.startsWith(x)) {
      return false;
    }
    final int len = x.length();
    return y.length() == len || y.charAt(len) == Path.SEPARATOR_CHAR;  
  }
798604
def abspath(self, path):
        """"""
        return os.path.abspath(os.path.join(os.path.dirname(self.path), path))
658397
def path(self):
        """"""
        yield self
        if not self.parent: return
        for node in self.parent.path: yield node
997845
def path(self) -> Tuple[InstanceKey]:
        """"""
        res = []
        inst: InstanceNode = self
        while inst.parinst:
            res.insert(0, inst._key)
            inst = inst.parinst
        return tuple(res)
267019
def path(self):
		''''''
		(x, y) = self.tile
		return os.path.join('%u' % self.zoom,
				    '%u' % y,
				    '%u.img' % x)
422816
function Path2(x, y) {
            this._points = new Array();
            this._length = 0.0;
            this.closed = false;
            this._points.push(new Vector2(x, y));
        }
504004
def finalize_path(self, path_num=None):
        """"""
        for c in self.consumers:
            c.finalize_path(path_num)
        self.result = [c.result for c in self.consumers]