long long modInverse(long long k, long long p)
{
k = k % p;
long long r;
if(k < 0)
{
r = -gcdD(p,-k)[2];
}
else
{
r = gcdD(p,k)[2];
}
return (p + r) % p;
}
int modInverse(int k) {
k = k % prime;
int r;
int * xyz;
if (k < 0) {
xyz = gcdD(prime,-k);
r = -xyz[2];
} else {
xyz = gcdD(prime, k);
r = xyz[2];
}
free(xyz);
return (prime + r) % prime;
}
// Gives the decomposition of the gcd of a and b. Returns [x,y,z] such that x = gcd(a,b) and y*a + z*b = x
static const std::array<TINT, 3> gcdD(TINT a, TINT b) {
if (b == 0)
return{ a, 1, 0 };
const TINT n = a / b;
const TINT c = a % b;
const std::array<TINT, 3> r = gcdD(b, c);
return{ r[0], r[2], r[1] - r[2] * n };
}
int * gcdD(int a, int b) {
int * xyz = malloc(sizeof(int) * 3);
if (b == 0) {
xyz[0] = a;
xyz[1] = 1;
xyz[2] = 0;
} else {
int n = floor(a/b);
int c = a % b;
int *r = gcdD(b,c);
xyz[0] = r[0];
xyz[1] = r[2];
xyz[2] = r[1]-r[2]*n;
free(r);
}
return xyz;
}
long long* gcdD(long long a, long long b)
{
long long* g = new long long[3];
if (b == 0)
{
g[0] = a;
g[1] = 1;
g[2] = 0;
return g;
}
else
{
long long n = a/b;
long long c = a%b;
long long* r = gcdD(b,c);
g[0] = r[0];
g[1] = r[2];
g[2] = r[1]-r[2]*n;
return g;
}
}
// Gives the multiplicative inverse of k mod prime. In other words (k * modInverse(k)) % prime = 1 for all prime > k >= 1
static TINT modInverse(TINT k, TINT prime) {
k = k % prime;
TINT r = (k < 0) ? -gcdD(prime, -k)[2] : gcdD(prime, k)[2];
return (prime + r) % prime;
}
