//---------------------------------------------------------------------------
// Copying construct the object
NaLinearUnitsChain::NaLinearUnitsChain (const NaLinearUnitsChain& rUnitsChain)
: NaConfigPart(rUnitsChain)
{
int i;
for(i = 0; i < rUnitsChain.count(); ++i)
addh(new NaLinearUnit(rUnitsChain.get(i)));
}
// {{{ stage_two()
// Algorithm 7.4.4 (4). Prime Numbers. Crandall & Pomerance.
static void stage_two(NTL::ZZ& x, EC::Point& Q, long B1, long B2, long D)
{
EC::Point S[D+1], T, R, Tmp;
NTL::ZZ_p alpha, beta[D+1], g;
doubleh(S[1], Q);
doubleh(S[2], S[1]);
// Compute S[d] = 2d*Q
for (long d=0; d<=D; ++d)
{
if(d>2)
addh(S[d], S[d-1], S[1], S[d-2]);
// Store the XZ products
beta[d] = S[d].X * S[d].Z;
}
long delta;
long B=B1-1;
g = 1;
T = (B-2*D)*Q;
R = B*Q;
for(long r=B; r<B2; r=r+2*D)
{
alpha = R.X * R.Z;
// TODO: Slow prime generation. Use cache.
for(long q=r+2; q<=r+2*D; q=NTL::NextPrime(q+1))
{
delta = (q-r)/2; // Distance to next prime
g *= (R.X-S[delta].X) * (R.Z+S[delta].Z) - alpha + beta[delta];
}
Tmp=R;
addh(R, R, S[D], T);
T=Tmp;
}
NTL::GCD(x, NTL::ZZ_p::modulus(), NTL::rep(g));
}
//---------------------------------------------------------------------------
// Construct the object
NaLinearUnitsChain::NaLinearUnitsChain (unsigned nUnits)
: NaConfigPart("LinearUnitsChain")
{
unsigned i;
char szBuf[20];
for(i = 0; i < nUnits; ++i){
addh(new NaLinearUnit());
// Assign instance name to each unit
sprintf(szBuf, "%d", i);
fetch(i).SetInstance(szBuf);
}
if(count() > 0)
fetch(0).act = true;
nMaxDim = 0;
iobuf[0] = iobuf[1] = NULL;
}
int main() {
int n ,m;
int x ,y;
init();
while(cin >> n >> m, n+m) {
chu();
for(int i = 0 ;i < n;i++) {
scanf("%d%d",&x,&y);
adds(x,y);
}
for(int i = 0; i < m;i++) {
scanf("%d%d",&x,&y);
addh(x,y);
}
cout << solve() << endl;
}
return 0;
}
// returns a non-trivial factor q of ZZ_p::modulus(), or 1 otherwise
void ECM_stage_two(ZZ& q, EC_p& Q, PrimeSeq& seq, long bound, long D) {
long B1 = seq.next();
if (B1<=2*D) {
// no primes to work with
set(q);
return;
}
EC_p R;
mul(R,B1,Q);
// check R for divisor
if (IsZero(R)) {
set(q);
return;
}
GCD(q,ZZ_p::modulus(),rep(R.Z));
if (!IsOne(q))
return;
EC_p T;
mul(T,B1-2*D,Q);
// compute point multiples S[d]=2*d*Q
EC_p S[D+1];
S[0]=Q;
doub(S[1],Q);
doub(S[2],S[1]);
for (long d=3; d<=D; ++d)
addh(S[d],S[d-1],S[1],S[d-2]);
ZZ_p beta[D+1];
for (long d=0; d<=D; ++d)
mul(beta[d],S[d].X,S[d].Z);
ZZ_p g,t,t2;
set(g);
ZZ_p alpha;
long r=B1;
long p=seq.next();
do {
mul(alpha,R.X,R.Z);
do {
long delta = (p-r)/2;
if (delta>D) break;
//g *= (R.X-S[delta].X) * (R.Z+S[delta].Z) - alpha + beta[delta];
sub(t,R.X,S[delta].X);
add(t2,R.Z,S[delta].Z);
t*=t2;
t-=alpha;
t+=beta[delta];
g*=t;
// next prime
p = seq.next();
if (p==0) {
// ran out of primes (should never happen)
p=NTL_MAX_LONG;
break;
}
} while (p<=bound);
if (p>bound)
break;
addh(T,R,S[D],T);
swap(R,T);
r+=2*D;
} while (true);
if (!IsZero(g))
GCD(q,ZZ_p::modulus(),rep(g));
else
set(q);
}
