for i in range(k):

		(x, y) = points[i]

		prod = 1

		for j in range(k):

			if i==j: continue

			(xj, yj) = points[j]

			prod = gfmul(prod, (gfmul(xj, inv[xj^x])))

		res ^= gfmul(y, prod)

	return res

###

import base64

import binascii

class SException(Exception): pass

def reconstruct_raw(*shares):

	"""Tries to recover the secret from its shares.

	:param shares: (((int) i, (bytes) share), ...)

	:return: (bytes) reconstructed secret. Too few shares returns garbage."""

	secret_len = len(shares[0][1])

	res = [None]*secret_len

	for i in range(secret_len):

		points = [(x, s[i]) for (x, s) in shares]

		res[i] = (get_constant_coef(*points))

	return bytes(res)

def reconstruct(*shares):

	"""Wraps reconstruct_raw.

	:param shares: ((str) share, ...)

	:return: (str) reconstructed secret. Too few shares returns garbage."""

	bs = reconstruct_raw(*(decode(s) for s in shares))

	try:

		return bs.decode(encoding="utf-8")

	except UnicodeDecodeError:

		raise SException('Failed to decode bytes to utf-8. Either you supplied invalid shares, or you missed the "raw" flag. Offending value: "{0}"'.format(bs))

def decode(share):

	try:

		(*_, i, share_str) = share.split(".")

	if not k<=n<255:

		raise InvalidParams("Failed k<=n<255, k={0}, n={1}".format(k, n))

	# we might be concerned with zero coefficients degenerating our polynomial, but there's no reason - we still need k shares to determine it is the case

	coefs = [int(secret_b)]+[int(b) for b in os.urandom(k-1)]

	points = [gf256.evaluate(coefs, i) for i in range(1, n+1)]

	return points

def generate_raw(secret, k, n):

	"""Splits secret into shares.

	:param secret: (bytes)

	:param k: number of shares necessary for secret recovery. 1 <= k <= n

	:param n: (int) number of shares generated. 1 <= n < 255

	:return: [(i, (bytes) share), ...]"""

	shares = [_share_byte(b, k, n) for b in secret]

	return [(i+1, bytes([s[i] for s in shares])) for i in range(n)]

def reconstruct_raw(*shares):

	"""Tries to recover the secret from its shares.

	:param shares: (((int) i, (bytes) share), ...)

	:return: (bytes) reconstructed secret. Too few shares return garbage."""

	secret_len = len(shares[0][1])

	res = [None]*secret_len

	for i in range(secret_len):

		points = [(x, s[i]) for (x, s) in shares]

		res[i] = (gf256.get_constant_coef(*points))

	return bytes(res)

def generate(secret, k, n, encoding="b32", label="", omit_k_n=False):

	"""Wraps generate_raw().

	:param secret: (str or bytes)

	:param k: number of shares necessary for secret recovery

	:param n: number of shares generated

	:param encoding: {hex, b32, b64} desired output encoding. Hexadecimal, Base32 or Base64.

	:param label: (str) any label to prefix the shares with

	:param omit_k_n: (boolean) suppress the default shares prefix

	:return: [(str) share, ...]"""

	if isinstance(secret,str):

		secret = secret.encode("utf-8")

	shares = generate_raw(secret, k, n)

	prefix = ""

	if label: