# KAKAURU game of numbers

import sys
sys.setrecursionlimit(3000)


zUnits = None
zBoard = None

def addUnit ( ln, a, b ):
    global zUnits
    ls     = [x for x in range(a,b+1)]
    print('R', ln, ls[1])
    lsNUMs = makeNUMSunit( ln, ls )
    ls2    = ['R', ln, ls, lsNUMs ]
    zUnits.append( ls2 )

def addUnid ( ln, a, b ):
    global zUnits
    a10,a1 = divmod(a,10)
    b10,b1 = divmod(b,10)
    ls     = [ x * 10 + a1 for x in range(a10,b10+1) ]
    print('C', ln, ls[1])
    lsNUMs = makeNUMSunit( ln, ls )
    ls2    = ['C', ln, ls, lsNUMs ]
    zUnits.append( ls2 )
    return ls

def makeNUMSunit ( ln, ls ) :
    def do ( lnls, k , j, lsNums, allLS) :
        if j > 9 : return allLS
        if j in lsNums:
            return do ( lnls, k , j+1, lsNums, allLS)
        if k == lnls :
            if sum(lsNums) == ln: return  allLS + [ lsNums ]
            return allLS
        lla =  do ( lnls, k + 1, 1, lsNums + [j], allLS) 
        return do ( lnls, k , j+1, lsNums, lla)
                
    return do ( len(ls), 0, 1, [], [] )


def reset ():
    global zBoard, zUnits
    zBoard = [None] * 100
    zUnits = []

def test1 ():
    reset()
    addUnit ( 6, 11, 13 )
    return zUnits 

def show1Unit(RC, n ):
    for k,u in enumerate(zUnits):
        if u[0]==RC and n == u[2][0]:
            return k,u

def showSQunits( n ):
    s = str(n) + ' '
    b = False
    for x in zUnits :
        for y in x[2:] :
            if y == n :
                s = s + str(x[:3])
                b = True
    if b : print(s)

def showSQall ():
    for k in range(11,100):
        showSQunits (k)

def showUnits():
    for u in zUnits:
        print(u)

def showUnitsZ():
    for u in zUnits:
        print(u[:3])


def printBoard():
    global counter_rec, counter
    print()
    print('----> counter:',counter, 'rec depth:', count_rec)
    for k in range(1,10):
        for j in range (1,10):
            x = zBoard[ k * 10 + j ]
            s = str(x) if x else '-'
            print(s,end='')
        print()

counter = 0
count_rec = 0 

def doFind () :
    '''
    try:
        doUnit(0)
    except Exception() as e:
        print('X', e)
        printBoard ()
    '''
    global count_rec,counter
    count_rec = 0
    counter   = 0
    doUnit(0)
    print('----> counter:', counter )
    
        

def doUnit ( k ):
    global count_rec, counter
    counter   += 1
    count_rec += 1
    #if counter % 1000000 == 0 : print(counter)
    
    def zkey (x) :
        a   = x[2]
        b   = a[0]
        c,d = divmod (b,10)
        return c+d
    
    global zUnits
    if zUnits == None:
        makeGame0()
        zUnits = sorted(zUnits,key=zkey)
    
    if k >= len( zUnits ) :
        printBoard ()
        return
    
    b = doINunitNum(k)
    count_rec -= 1
    

def doINunitNum( k ):
    global count_rec, counter
    counter   += 1
    count_rec += 1
    
    unit     = zUnits[k]
    lsSQ     = unit[2]
    lslsNums = unit[3]
    #print(lsSQ, lslsNums)
    
    def doLSLSnums ( j, k ):
        # loop on all possible for a unit
        global count_rec, counter
        counter   += 1    
        count_rec += 1
    
        for lsNums in lslsNums :
            b  = doLSnums   ( j, 0, lsNums)
        
        
        
    def doLSLSnumsOOO ( j, k ):
        # loop on all possible for a unit
        global count_rec, counter
        counter   += 1    
        count_rec += 1
    
        if j >= len(lslsNums) :
            count_rec -= 1
            return False
        lsNums = lslsNums[j]
        b  = doLSnums   ( j, 0, lsNums)
        b2 = doLSLSnums ( j + 1, k    )
        count_rec -= 1
        
    def doLSnums( j, m , lsNums ) :
        
        global count_rec, counter
        counter   += 1
        count_rec += 1
        
        nonlocal lsSQ, unit
        if m >= len(lsNums) :  
            b = doUnit(k+1)
            b = doLSLSnums(j + 1, k)
            count_rec -= 1
            return b
        
        sq = lsSQ[m]
        z = zBoard[sq]
        if z : # square has a num already
            if z == lsNums[m] :
                b = doLSnums( j , m + 1, lsNums)
                count_rec -= 1
                return b
            count_rec -= 1
            return False

        zBoard[sq] = lsNums[m] # place a new  num in square
        b = doLSnums( j , m+1, lsNums)
        zBoard[sq] = None # remove num on the way back
        count_rec -= 1 # count recursive calls
        return b

    # body doINunitNum
    
    b = doLSLSnums( 0, k )
    count_rec -= 1
    return b      

def makeGame0 ():
    reset()
    addUnit (  6, 11, 13 ) 
    addUnit ( 12, 21, 23 )
    addUnit ( 21, 31, 33 )

    addUnid ( 10, 11, 31 )
    addUnid ( 13, 12, 32 )
    addUnid ( 16, 13, 33 )
#makeGame0 ()

def makeGame1 ():
    reset()
    addUnit ( 32, 11, 15 ) ; addUnit ( 17, 17, 19 )
    addUnit ( 23, 21, 25 ) ; addUnit ( 20, 27, 29 )
    addUnit ( 16, 31, 33 ) ; addUnit ( 20, 35, 37 )
    addUnit ( 27, 43, 46 ) ; addUnit ( 16, 48, 49 )
    addUnit ( 25, 51, 54 ) ; addUnit ( 26, 56, 59 )
    addUnit (  9, 61, 62 ) ; addUnit ( 26, 64, 67 )
    addUnit ( 18, 73, 75 ) ; addUnit ( 23, 77, 79 )
    addUnit ( 19, 81, 83 ) ; addUnit ( 32, 85, 89 )
    addUnit ( 11, 91, 93 ) ; addUnit ( 26, 95, 98 )
    #addUnit ( 11, 91, 93 ) ; addUnit ( 27, 95, 99 ) 
    
    addUnid ( 24, 11, 31 ) ; addUnid (  5, 51, 61 ) ; addUnid ( 17, 81, 91 )
    addUnid (  9, 12, 32 ) ; addUnid ( 16, 52, 62 ) ; addUnid (  4, 82, 92 )
    addUnid ( 35, 13, 53 ) ; addUnid ( 17, 73, 93 )
    addUnid ( 17, 14, 24 ) ; addUnid ( 11, 44, 74 )
    addUnid ( 13, 15, 45 ) ; addUnid ( 30, 65, 95 )
    addUnid ( 28, 36, 66 ) ; addUnid ( 17, 86, 96 )
    addUnid ( 24, 17, 37 ) ; addUnid ( 35, 57, 97 )
    addUnid (  4, 18, 28 ) ; addUnid ( 14, 48, 58 ) ; addUnid ( 23, 78, 98 )
    addUnid ( 17, 19, 29 ) ; addUnid ( 16, 49, 59 ) ; addUnid ( 11, 79, 99 )

def makeGame2 ():
    reset()
    zBoard [34] = 6
    zBoard [44] = 7
    zBoard [43] = 5
    zBoard [58] = 5
    zBoard [77] = 4
    addUnit (  3, 24, 25 ) 
    addUnit ( 16, 32, 36 ) ; addUnit (  4, 38, 39 )
    addUnit ( 25, 42, 46 ) ; addUnit (  3, 48, 49 )
    addUnit (  9, 53, 54 ) ; addUnit ( 17, 56, 59 )
    addUnit (  7, 62, 64 ) ; addUnit ( 17, 67, 69 )
    addUnit ( 11, 72, 73 ) ; addUnit ( 19, 75, 78 )
    addUnit (  6, 85, 87 )
    addUnit (  4, 96, 97 )
     
    
    addUnid ( 12, 32, 42 ) ; addUnid ( 11, 62, 72 ) 
    addUnid ( 15, 33, 73 )  
    addUnid ( 23, 24, 64 )
    addUnid (  7, 25, 45 ) ; addUnid (  6, 75, 85 )
    addUnid (  9, 36, 56 ) ; addUnid (  6, 76, 96 )
    addUnid ( 16, 57, 97 ) 
    #addUnid ( 26, 38, 78 ) 
    addUnid ( 10, 39, 69 )