"""Method B (independent of method A's code): Cayley-Dickson integer octonions Z^8 (maximal at 3),
an explicit Zorn frame found mod 3^6, orders transported into CD coordinates, and BFS in which the
children of a stable lattice L are ALL stable M with 3L <= M < L (all submodules of L/3L, enumerated
as sums of cyclic submodules), canonical form = Howell-type echelon over Z/3^6 written afresh.
Counts LEFT ideals (method A counts right ideals; conjugation swaps them)."""
import itertools, json, sys, time
from multiprocessing import Pool
P=3; NMOD=6; MOD=P**NMOD
def cd(x,y):
    if len(x)==1: return (x[0]*y[0],)
    h=len(x)//2; a,b,c,d=x[:h],x[h:],y[:h],y[h:]
    cj=lambda z:(z[0],)+tuple(-t for t in z[1:])
    A=cd(a,c); B=cd(cj(d),b); C=cd(d,a); D=cd(b,cj(c))
    return tuple(s-t for s,t in zip(A,B))+tuple(s+t for s,t in zip(C,D))
def m(x,y): return tuple(t%MOD for t in cd(tuple(x),tuple(y)))
ONE=(1,)+(0,)*7
def nrm(x): return sum(t*t for t in x)
# --- Zorn frame inside CD mod 3^6 ---
w=None
for cand in itertools.product(range(0,28),repeat=3):
    v=(0,)+cand+(0,0,0,0)
    if nrm(v)%MOD==MOD-1: w=v;break
assert w is not None
inv2=pow(2,-1,MOD)
e=tuple((ONE[i]+w[i])*inv2%MOD for i in range(8)); f=tuple((ONE[i]-e[i])%MOD for i in range(8))
assert m(e,e)==e
std=[tuple(int(i==j) for i in range(8)) for j in range(8)]
def rank3(vs):
    R=[]
    for v in vs:
        v=[t%3 for t in v]
        for r in R:
            c=next(i for i,t in enumerate(r) if t)
            if v[c]: k=v[c]*pow(r[c],-1,3); v=[(a-k*b)%3 for a,b in zip(v,r)]
        if any(v): R.append(v)
    return len(R)
Uimg=[m(m(e,x),f) for x in std]
U=[]
for x in Uimg:
    if rank3(U+[x])>len(U): U.append(x)
assert len(U)==3
u1,u2,u3=U
lam=m(u1,m(u2,u3))
k=next(i for i in range(8) if e[i]%3)
lamc=lam[k]*pow(e[k],-1,MOD)%MOD
assert all((lam[i]-lamc*e[i])%MOD==0 for i in range(8)) and lamc%3
u3=tuple(t*pow(lamc,-1,MOD)%MOD for t in u3)
v1,v2,v3=m(u2,u3),m(u3,u1),m(u1,u2)
FR=[e,u1,u2,u3,v1,v2,v3,f]
# verify the Zorn table: u_i u_j = eps v_k, v_i v_j = -eps u_k, u_i v_j = d e, v_i u_j = d f, e/f actions
def comb(coeffs): return tuple(sum(c*FR[j][i] for j,c in coeffs)%MOD for i in range(8))
Z=(0,)*8
eps={(1,2):(3,1),(2,3):(1,1),(3,1):(2,1),(2,1):(3,-1),(3,2):(1,-1),(1,3):(2,-1)}
def zorn_prod(i,j):  # in frame indices 0..7 = e,u1,u2,u3,v1,v2,v3,f ; returns list of (index,coef)
    if i==0: return [(j,1)] if j in (0,1,2,3) else []
    if i==7: return [(j,1)] if j in (4,5,6,7) else []
    if i in (1,2,3):
        if j==7: return [(i,1)]
        if j in (1,2,3): return [(eps[(i,j)][0]+3,eps[(i,j)][1])] if (i,j) in eps else []
        if j in (4,5,6): return [(0,1)] if j-3==i else []
        return []
    if j==0: return [(i,1)]
    if j in (4,5,6): return [(eps[(i-3,j-3)][0],-eps[(i-3,j-3)][1])] if (i-3,j-3) in eps else []
    if j in (1,2,3): return [(7,1)] if j==i-3 else []
    return []
for i in range(8):
    for j in range(8):
        assert m(FR[i],FR[j])==comb(zorn_prod(i,j)), (i,j)
# frame is a Z_3 basis
assert rank3(FR)==8
# --- canonical form over Z/3^6 (column-pivot Howell echelon) ---
def val(t):
    t%=MOD
    if t==0: return NMOD
    k=0
    while t%3==0: t//=3;k+=1
    return k
def canon(gens):
    rows=[[t%MOD for t in g] for g in gens]+[[MOD*(i==j)%MOD for i in range(8)] for j in range(8)]
    rows=[r for r in rows if any(r)]
    out=[]
    for c in range(8):
        # pick row with minimal valuation at column c
        best=None
        for r in rows:
            if r[c]%MOD and (best is None or val(r[c])<val(best[c])): best=r
        if best is None: out.append([0]*8); continue
        rows.remove(best)
        vb=val(best[c]); unit=(best[c]//P**vb)%MOD
        best=[t*pow(unit,-1,MOD)%MOD for t in best]
        new=[]
        for r in rows:
            if r[c]%MOD:
                q=(r[c]//P**vb)%MOD
                r=[(a-q*b)%MOD for a,b in zip(r,best)]
            if any(r): new.append(r)
        # Howell completeness: add 3^(N-vb) * best (it vanishes in column c)
        extra=[(t*P**(NMOD-vb))%MOD for t in best]
        if any(extra): new.append(extra)
        rows=new; out.append(best)
    # reduce entries above pivots
    for c in range(8):
        r=out[c]
        if not any(r): continue
        pv=P**val(r[c])
        for d in range(c):
            q=out[d][c]//pv
            if q: out[d]=[(a-q*b)%MOD for a,b in zip(out[d],r)]
    return tuple(tuple(r) for r in out)
def logindex(H):
    return sum(val(H[c][c]) if any(H[c]) else NMOD for c in range(8))
def member(H,v):
    v=[t%MOD for t in v]
    for c in range(8):
        if v[c]%MOD==0: continue
        if not any(H[c]): return False
        vb=val(H[c][c])
        if val(v[c])<vb: return False
        q=(v[c]//P**vb)*pow((H[c][c]//P**vb)%MOD,-1,MOD)%MOD
        v=[(a-q*b)%MOD for a,b in zip(v,H[c])]
    return not any(v)
ORD={'Q':(0,1,4,7),'U':(0,1,7),'N4':(0,1,5,7),'P5':(0,1,2,6,7),'P6':(0,1,2,4,6,7),'O':tuple(range(8))}
def order_gens(name):
    S=ORD[name]
    return [FR[i] for i in S]+[tuple(3*t for t in s) for s in std]
def basis_of(H): return [list(r) for r in H if any(r)]
def submodules_children(H,gens):
    """all stable M with 3L<=M<L, for L=H stable (left action x -> y x)."""
    B=basis_of(H)
    # coordinates mod 3 of y*b in basis B: solve via member-like reduction tracking coefficients
    def coords(v):
        v=[t%MOD for t in v]; co=[0]*len(B)
        for idx,r in enumerate(B):
            c=next(i for i in range(8) if r[i]%MOD)
            if v[c]%MOD==0: continue
            vb=val(r[c]); q=(v[c]//P**vb)*pow((r[c]//P**vb)%MOD,-1,MOD)%MOD
            co[idx]=q; v=[(a-q*b)%MOD for a,b in zip(v,r)]
        assert not any(v),'unstable'
        return co
    # B may have more than 8 rows? Howell rows are 8 (some zero removed) -> lattice basis rank 8
    assert len(B)==8
    acts=[[ [c%3 for c in coords(m(y,b))] for b in B] for y in gens]   # row i = image of basis i
    def apply(Mx,v): return tuple(sum(v[i]*Mx[i][j] for i in range(8))%3 for j in range(8))
    def ech(vs):
        R=[]
        for v in vs:
            v=list(v)
            for r in R:
                c=next(i for i,t in enumerate(r) if t)
                if v[c]: k=v[c]*r[c]%3; v=[(a-k*b)%3 for a,b in zip(v,r)]
            if any(v):
                c=next(i for i,t in enumerate(v) if t); inv=v[c]%3; v=[t*inv%3 for t in v]
                R=[[(a-r[c]*b)%3 for a,b in zip(r,v)] for r in R]; R.append(v)
        return tuple(sorted(tuple(r) for r in R))
    cyc={}
    for v in itertools.product(range(3),repeat=8):
        if not any(v) or v[next(i for i,t in enumerate(v) if t)]!=1: continue
        S=ech([v])
        while True:
            S2=ech(list(S)+[apply(Mx,s) for s in S for Mx in acts])
            if S2==S: break
            S=S2
        cyc[S]=1
    cyc=list(cyc)
    subs={():1}; fr=[()]
    while fr:
        nf=[]
        for s in fr:
            for c in cyc:
                t=ech(list(s)+list(c))
                if t not in subs: subs[t]=1; nf.append(t)
        fr=nf
    out=[]
    for s in subs:
        if len(s)==8: continue
        gensM=[[sum(cf*B[i][j] for i,cf in enumerate(r)) for j in range(8)] for r in s]+[[3*t for t in b] for b in B]
        out.append(canon(gensM))
    return out
def worker(args):
    H,name=args
    return submodules_children(H,order_gens(name))
def run(name,procs=8):
    gens=order_gens(name)
    O=canon(std); Lam=canon(gens)
    seen={O:logindex(O)}; fr=[O]; t=time.time()
    with Pool(procs) as pool:
        while fr:
            res=pool.map(worker,[(H,name) for H in fr],chunksize=1)
            nf=[]
            for ch in res:
                for K in ch:
                    if all(t%3==0 for r in K for t in r): continue
                    if K not in seen: seen[K]=logindex(K); nf.append(K)
            fr=nf; print(name,'frontier',len(fr),'total',len(seen),round(time.time()-t,1),flush=True)
    shift=8-len(ORD[name]); PO={};PL={}
    for K,k in seen.items():
        PO[k]=PO.get(k,0)+1
        if all(member(Lam,r) for r in K if any(r)): PL[k-shift]=PL.get(k-shift,0)+1
    return {'order':name,'side':'L','P_O':dict(sorted(PO.items())),'P_Lambda':dict(sorted(PL.items())),'n_primitive':len(seen),'frame_w':w}
if __name__=='__main__':
    res=[]
    for n in sys.argv[1].split(','):
        r=run(n); print(json.dumps(r),flush=True); res.append(r)
        json.dump(res,open(f'results-B-{sys.argv[1].replace(",","_")}.json','w'),indent=1)
