docs: def levenshtein(seq1, seq2, normalized=False, max_dist=-1):
  	"""Compute the absolute Levenshtein distance between the two sequences
  	`seq1` and `seq2`.
  	
  	The Levenshtein distance is the minimum number of edit operations necessary
  	for transforming one sequence into the other. The edit operations allowed are:
  	
  		* deletion:     ABC -> BC, AC, AB
  		* insertion:    ABC -> ABCD, EABC, AEBC..
  		* substitution: ABC -> ABE, ADC, FBC..
  	
  	The `max_dist` parameter controls at which moment we should stop computing the
  	distance between the provided sequences. If it is a negative integer, the
  	distance will be computed until the sequences are exhausted; otherwise, the
  	computation will stop at the moment the calculated distance is higher than
  	`max_dist`, and then return -1. For example:
  	
  		>>> levenshtein("abc", "abcd", max_dist=1)  # dist = 1
  		1
  		>>> levenshtein("abc", "abcde", max_dist=1) # dist = 2
  		-1
  	
  	This can be a time saver if you're not interested in the exact distance, but
  	only need to check if the distance between the given sequences is below a
  	given threshold.
  	
  	The `normalized` parameter is here for backward compatibility; providing
  	it will result in a call to `nlevenshtein`, which should be used directly
  	instead. 
  	"""
  	if normalized:
  		return nlevenshtein(seq1, seq2, method=1)
  		
  	if seq1 == seq2:
  		return 0
  	
  	len1, len2 = len(seq1), len(seq2)
  	if max_dist >= 0 and abs(len1 - len2) > max_dist:
  		return -1
  	if len1 == 0:
  		return len2
  	if len2 == 0:
  		return len1
  	if len1 < len2:
  		len1, len2 = len2, len1
  		seq1, seq2 = seq2, seq1
  	
  	column = array('L', range(len2 + 1))
  	
  	for x in range(1, len1 + 1):
  		column[0] = x
  		last = x - 1
  		for y in range(1, len2 + 1):
  			old = column[y]
  			cost = int(seq1[x - 1] != seq2[y - 1])
  			column[y] = min(column[y] + 1, column[y - 1] + 1, last + cost)
  			last = old
  		if max_dist >= 0 and min(column) > max_dist:
  			return -1
  	
  	if max_dist >= 0 and column[len2] > max_dist:
  		# stay consistent, even if we have the exact distance
  		return -1
  	return column[len2]