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 = str(input())
t = str(input())


def dp(i, j, steps):
    if j == len(t):
        if i < len(s):
            for idx in range(i, len(s)):
                steps.append('DELETE %s' % (idx+1))
        return steps
    
    skip = None
    if i < len(s) and s[i] == t[j]:
        skip = dp(i+1, j+1, steps)

    replace = dp(i+1, j+1, steps + ['REPLACE %s %s' %  (j+1, t[j])])
    insert = dp(i, j+1, steps + ['INSERT %s %s' % (j+1, t[j])])

    if skip != None and len(skip) < len(insert) and len(skip) < len(replace):
        return skip
    
    return insert if len(insert) < len(replace) else replace

steps = dp(0, 0, [])

print(len(steps))
for step in steps:
    print(step)

