def integer_partitions(n,l=0):
    l = n if l == 0 else l
    a = [0 for i in range(n + 1)]
    k = 1
    a[0] = 0
    a[1] = n
    while k != 0:
        x = a[k - 1] + 1
        y = a[k] - 1
        k -= 1
        while x <= y and k < l - 1:
            a[k] = x
            y -= x
            k += 1
        a[k] = x + y
        yield a[:k + 1]

def exists(a,b):
    return max(a) <= sum(b) and max(b) <= sum(a) and max(a) + max(b) <= max(sum(a),sum(b))

def no_family(a,b):
    return sum(a)*sum(b) + 1 == sum([ai^2 for ai in a]) + sum([bi^2 for bi in b])

def alpha_inv_exists(a,b):
    return sum(a) in b or sum(b) in a

def beta_decreases(a,b):
    return len(a)*sum(b) - sum(a) < sum(a) or len(b)*sum(a) - sum(b) < sum(b)

def operations(a,b,N):
    yield (a,b)
    yield (b,a)
    if 2*sum(a)+sum(b) <= N:
        for tup in operations(a,[sum(a)]+b,N):
            yield tup
    if sum(a)+len(b)*sum(a)-sum(b) <= N:
        for tup in operations(a,[sum(a) - bi for bi in b],N):
            yield tup

def mut(a,b):
    return list(set([(tuple(tup[0]),tuple(tup[1])) for tup in operations([1],[1],a+b) if sum(tup[0]) <= a and sum(tup[1]) <= b]))

N0 = 1
N = 10
for k in range(N0,N0+N):
    da = 4
    db = da+k
    #if gcd(da,db) > 1:
    #    continue
    print("---",da,db)
    count = 0
    for a in integer_partitions(da):
        for b in integer_partitions(db):
            if exists(a,b) and no_family(a,b): # and not alpha_inv_exists(a,b) and not beta_decreases(a,b):
                count += 1
                print(a,b)
    print(count)
    #print(len(mut(da,db)))