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.
from functools import lru_cache


def main():
    s = input()
    t = input()
    
    @lru_cache(None)
    def dp(i, j):
        if i == len(s) and t == len(t):
            return (0, tuple())
        
        if i == len(s):
            changes = len(t) - j
            ans = []
            for k in range(j, len(t)):
                ans.append("INSERT " + str(k + 1) + " " + t[k])
            return (changes, tuple(ans))
        if j == len(t):
            changes = len(s) - i
            ans = []
            for k in range(i, len(s)):
                ans.append("REMOVE "+ str(k + 1) + " " + s[k])
            
            return (changes, tuple(ans))
        
        changes = 1
        if s[i] == t[j]:
            return dp(i + 1, j + 1)
        # remove
        one = dp(i + 1, j)
        # INSERT
        two = dp(i, j + 1)
        # REPLACE
        three = dp(i + 1, j + 1)
        
        res = min(one, two, three)
        if res == one:
            return (res[0] + 1, tuple(list(res[1]) + ["REMOVE " + str(i + 1) + " " +  s[i] ]))
        elif res == two:
            return (res[0] + 1, tuple(list(res[1]) + ["INSERT " + str(i + 1) + " " +  t[j] ]))

        else:
            return (res[0] + 1, tuple(list(res[1]) + ["REPLACE " + str(i + 1) + " " +  t[j] ]))

    
    ANS = dp(0, 0)
    print(ANS[0])
    second = ANS[1][::-1]
    # print(second)
    diff = 0
    for line in second:
        action, num , word = line.split(" ")
        n = int(num) + diff
        print("{action} {n} {word}".format(action = action, n = n, word = word ))
        if action == "INSERT":
            diff += 1




main()