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()
n = len(s)
m = len(t)

DP = [[-1] * (1010 + 1) for _ in range(1010 + 1)]


def dp(i, j):
    if (i == n or j == m):
        DP[i][j] = n - i + m - j
        return DP[i][j]

    if (DP[i][j] != -1):
        return DP[i][j]

    ans = dp(i + 1, j + 1) + 1
    if (s[i] == t[j]):
        ans = dp(i + 1, j + 1)        # advance
    ans = min(ans, dp(i, j + 1) + 1)  # insert
    ans = min(ans, dp(i + 1, j) + 1)  # erase

    DP[i][j] = ans
    return DP[i][j]


def recursive_print(i, j, d):
    if (i == n and j == m) or (DP[i][j] == 0):
        return

    if s[i] == t[j] and DP[i][j] == DP[i + 1][j + 1]:
        recursive_print(i + 1, j + 1, d)

    elif DP[i][j] == DP[i + 1][j + 1] + 1:
        print("REPLACE", i + d + 1, t[j])
        recursive_print(i + 1, j + 1, d)

    elif DP[i][j] == DP[i][j + 1] + 1:
        print("INSERT", i + d + 1, t[j])
        recursive_print(i, j + 1, d + 1)

    elif (DP[i][j] == DP[i + 1][j] + 1):
        print("DELETE", i + d + 1)
        recursive_print(i + 1, j, d - 1)


print(dp(0, 0))

recursive_print(0, 0, 0)

	 				    					 		  	 		 			