public class CivitasBigInteger extends CivitasBigintegerBase {

	CivitasBigInteger(final BigInteger integer) {
		super(integer);
	}

	public CivitasBigInteger add(final CivitasBigInteger x) {
		if (x == ZERO) {
			return this;
		}
		return new CivitasBigInteger(i.add(x.i));
	}

	public CivitasBigInteger mod(final CivitasBigInteger q) {
		BigInteger m = this.i.mod(q.i);
		if (this.i.equals(m)) {
			return this;
		}
		return new CivitasBigInteger(m);
	}

	public CivitasBigInteger modAdd(final CivitasBigInteger x, final CivitasBigInteger p) {
		if (x == ZERO) {
			return this.mod(p);
		}
		return new CivitasBigInteger(i.add(x.i).mod(p.i));
	}

	public CivitasBigInteger modPow(final CivitasBigInteger x, final CivitasBigInteger p) {
		return new CivitasBigInteger(this.i.modPow(x.i, p.i));
	}

	public CivitasBigInteger multiply(final CivitasBigInteger x) {
		if (x == ONE) {
			return this;
		}
		if (x == ZERO) {
			return ZERO;
		}
		return new CivitasBigInteger(this.i.multiply(x.i));
	}

	public CivitasBigInteger modMultiply(final CivitasBigInteger x, final CivitasBigInteger p) {
		if (x == ZERO) {
			return ZERO;
		}
		if (x == ONE) {
			return this.mod(p);
		}
		return new CivitasBigInteger(this.i.multiply(x.i).mod(p.i));
	}

	public CivitasBigInteger modDivide(final CivitasBigInteger x, final CivitasBigInteger p) {
		if (x == ONE) {
			return this.mod(p);
		}
		return new CivitasBigInteger(this.i.multiply(x.i.modInverse(p.i)).mod(p.i));
	}

	public CivitasBigInteger subtract(final CivitasBigInteger x) {
		if (x == ZERO) {
			return this;
		}
		return new CivitasBigInteger(this.i.subtract(x.i));
	}

	public CivitasBigInteger modSubtract(final CivitasBigInteger x, final CivitasBigInteger p) {
		if (x == ZERO) {
			return this.mod(p);
		}
		return new CivitasBigInteger(this.i.subtract(x.i).mod(p.i));
	}
}

public class CivitasBigintegerBase implements CivitasBigIntegerInterface {

	public final BigInteger i;

	public CivitasBigintegerBase(final BigInteger i) {
		this.i = i;
	}

	public int bitLength() {
		return i.bitLength();
	}

	public int intValue() {
		return i.intValue();
	}

	public int compareTo(final CivitasBigInteger n) {
		return i.compareTo(n.i);
	}

	@Override
	public String toString() {
		return i.toString();
	}

	@Override
	public boolean equals(final Object object) {
		return object instanceof CivitasBigInteger other && this.i.equals(other.i);
	}

	@Override
	public int hashCode() {
		return i.hashCode();
	}

	public byte[] toByteArray() {
		return i.toByteArray();
	}

	@Override
	public BigInteger asBigint() {
		return i;
	}
}

public interface CivitasBigIntegerInterface extends Constants {

	BigInteger asBigint();

	default boolean isProbablePrime(final int certainty) {
		return asBigint().isProbablePrime(certainty);
	}

	default CivitasBigInteger nextProbablePrime() {
		return new CivitasBigInteger(asBigint().nextProbablePrime());
	}

	default CivitasBigInteger divide(final CivitasBigInteger q) {
		return new CivitasBigInteger(asBigint().divide(q.i));
	}

	default CivitasBigInteger modInverse(final CivitasBigInteger p) {
		return new CivitasBigInteger(asBigint().modInverse(p.i));
	}

	default CivitasBigInteger modNegate(final CivitasBigInteger p) {
		return new CivitasBigInteger(asBigint().negate().mod(p.i));
	}

	default CivitasBigInteger pow(final int j) {
		return new CivitasBigInteger(asBigint().pow(j));
	}
}

public interface CivitasBigIntegerFactory {
	static CivitasBigInteger obtain(final BigInteger i) {
		return new CivitasBigInteger(i);
	}

	static CivitasBigInteger obtain(final byte[] bytes) {
		return new CivitasBigInteger(new BigInteger(bytes));
	}

	static CivitasBigInteger obtain(final int signum, final byte[] magnitude) {
		return new CivitasBigInteger(new BigInteger(signum, magnitude));
	}

	static CivitasBigInteger obtain(final int i, final Random random) {
		return new CivitasBigInteger(new BigInteger(i, random));
	}

	static CivitasBigInteger obtain(final int i) {
		return new CivitasBigInteger(BigInteger.valueOf(i));
	}
}