There is a string *s*, consisting of capital Latin letters. Let's denote its current length as |*s*|. During one move it is allowed to apply one of the following operations to it: 
 -  INSERT *pos* *ch* — insert a letter *ch* in the string *s* in the position *pos* (1 ≤ *pos* ≤ |*s*| + 1, *A* ≤ *ch* ≤ *Z*). The letter *ch* becomes the *pos*-th symbol of the string *s*, at that the letters shift aside and the length of the string increases by 1. -  DELETE *pos* — delete a character number *pos* (1 ≤ *pos* ≤ |*s*|) from the string *s*. At that the letters shift together and the length of the string decreases by 1. -  REPLACE *pos* *ch* — the letter in the position *pos* of the line *s* is replaced by *ch* (1 ≤ *pos* ≤ |*s*|, *A* ≤ *ch* ≤ *Z*). At that the length of the string does not change. 
Your task is to find in which minimal number of moves one can get a *t* string from an *s* string. You should also find the sequence of actions leading to the required results.
The first line contains *s*, the second line contains *t*. The lines consist only of capital Latin letters, their lengths are positive numbers from 1 to 1000.
s = input()
t = input()
memo = {}
ops = {}

def dp(i, j):
    if i == len(s) or j == len(t):
        return max(len(s) - i, len(t) - j)
    
    if (i, j) in memo:
        return memo[(i, j)]
    
    minCost = float("inf")
    
    if s[i] == t[j]:
        minCost = dp(i + 1, j + 1)
    else:
        insert = dp(i, j + 1)
        delete = dp(i + 1, j)
        update = dp(i + 1, j + 1)
        
        minCost = min(insert, update, delete) 
        
        if insert == minCost:
            ops[j] = ('INSERT', j + 1, t[j])
        elif delete == minCost:
            ops[j] = ('DELETE', j + 1, t[j])
        elif update == minCost:
            ops[j] = ('REPLACE', j + 1, t[j])
            
        minCost += 1
     
    memo[(i, j)] = minCost
    return minCost

print(dp(0, 0))
# print(ops)
ans = list(ops.values())
ans.sort(key = lambda x: x[1])
# print(ans)
for op in ans:
    print(*op)