def is_negative(x):
        return int(x + x) & 1

    p = 2^255 - 19
    f = GF(p)
    A = 486662
    sqrtm1 = f(2)^((p - 1) / 4)
    if is_negative(sqrtm1): sqrtm1 = -sqrtm1
    u = sqrtm1

    def invsqrt(x):
        isr = x^((p - 5) / 8)
        quartic = x * isr^2
        if quartic == -1 or quartic == -sqrtm1:
            isr = isr * sqrtm1
        is_square = quartic == 1 or quartic == -1
        return isr, is_square

    def fast_hash_to_curve(q):
        r = u * q^2
        num = A * (A^2 * r - (r + 1)^2)
        den = (r + 1)^3
        # x = -A / (r + 1)
        # y = x^3 + A*x^2 + x
        # y = A^3/(r + 1)^2 - A^3/(r + 1)^3 - A/(r + 1)
        # y = (A^3*r - A*(r + 1)^2) / (r + 1)^3
        isr, is_square = invsqrt(num * den)
        # if is_square: isr = sqrt(1 / (num * den))
        # if not is_square: isr = sqrt(u / (num * den))
        x = -A * (num * (r + 1)^2 * isr^2)
        # x = -A * num * (r + 1)^2 * sqrt(1 / (num * den))^2
        # x = -A * num * (r + 1)^2 * 1 / (num * den)
        # x = -A * (r + 1)^2 * 1 / den
        # x = -A / (r + 1)
        y = num * isr
        # y = num * sqrt(1 / (num * den))
        # y = sqrt(num^2 / (num * den))
        # y = sqrt(num / den)
        if is_square: q = 1
        x = q^2 * x
        # x = q^2 * -A * u / (r + 1)
        # x = -A * u * q^2 / (r + 1)
        # x = -A * r / (r + 1)
        y = q * y
        # y = q * sqrt(u * num / den)
        # y = sqrt(u * q^2 * num / den)
        # y = sqrt(r * num / den)
        if is_negative(y): y = -y
        if not is_square: y = -y
        return (x, y)

    def fast_curve_to_hash(p):
        x, y = p
        t0 = A + x
        t1 = x
        # if is_positive(y): r = u*q^2 = -(A + x)/x
        # if is_negative(y): r = u*q^2 = -x/(A + x)
        isr, is_square = invsqrt(-t0 * t1 * u)
        # isr = sqrt(-1 / ((A + x) * x * u))
        if not is_square:
            return false
        num = t0
        if is_negative(y): num = t1
        q = num * isr
        # if is_positive(y): q = (A + x) * sqrt(1 / (-x * (A + x) * u)) = sqrt(-(A + x) / (x * u))
        # if is_positive(y): q = sqrt(-(A + x) / (x * u))
        # if is_negative(y): q = x * sqrt(1 / (-x * (A + x) * u)) = sqrt(-x / ((A + x) * u))
        # if is_negative(y): q = sqrt(-x / ((A + x) * u))
        if is_negative(q): q = -q
        return q