#Generating restricted growth sequences in Co-RGC order

#initialization
reset()
n=5   # length of the sequences, changeable
b=[]
for i in range(n+2): b.append(i-1) #(i=1;i<=n;i++) b[i]=i-1;
L=[]

#type the sequence
def type():
    t=tuple(b[1:n+1])
    L.append(t)
    print L.index(t)+1,t

#functions on subexcedant sequences
def mu_SE(k,i,w):
    if (k==n): return n-1
    else: return (w-1)

def DegreeOne_SE(m,v):
    if m==2:return 1
    else: return 0

def Lowest_SE(m):
    return 0

def SecLargest_SE(m,w):
    return m-3

#functions on ascent sequences
def mu_A(k,i,w):
    if i>=w: return i
    elif i>=b[k+1]: return w
    elif i< b[k+1]: return w-1

def DegreeOne_A(m,v):
    if v==m-1 or (v==m-2 and b[m]==0):
        b[m-1]=m-2
        return 1
    else: return 0

def Lowest_A(m):
    return 0

def SecLargest_A(m,w):
    if (w==m-2 and b[m]>0 and b[m]<m-1):
        return b[m]-1
    else: return (m-3)

#functions on restricted growth functions
def mu_R(k,i,w):
    if i>=w: return i
    elif b[k+1]<w: return w
    else: return w-1

def DegreeOne_R(m,v):
    if (v==m-1) or (v==m-2 and b[m]<m-2):
        b[m-1]=m-2
        return 1
    else: return 0

def Lowest_R(m):
    return 0

def SecLargest_R(m, w):
    return m-3

#functions on staircase words
def mu_S(k,i,w):
    return i

def DegreeOne_S(m,v):
    if b[m]==m-1:
        b[m-1]=m-2
        b[m-2]=m-3
        return 1
    else: return 0

def Lowest_S(m):
    if b[m]>1 and b[m]<=m-2: return b[m]-1
    else: return 0

def SecLargest_S(m,w):
    return m-3


#Generating procedure, change XX in the function call
#with SE, A, R, or S to generate the desired list
def Gen2(k,x,drc,v):
    b[k]=x
    u=mu_XX(k,x,v)
    if DegreeOne_XX(k,u)==1:
        type()
    else:
        c=Lowest_XX(k)
        d=SecLargest_XX(k,u)
        if drc%2==1:
            for i in [c..d]:
                Gen2(k-1,i,i,u)
        Gen2(k-1,k-2,k-1-(drc%2),u)
        if drc%2==0:
            for i in reversed [c..d]:
                Gen2(k-1,i,i+1,u)

#Main call
Gen2(n+1,0,0,0)