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.
import heapq
from collections import defaultdict, Counter
graph = defaultdict(set)
def listinput():
    return list(map(int, input().split()))
def editDistance(word1, word2):
    dp  = [[i] + ([0] * (len(word1))) for i in range(len(word2)+1)]
    dp[0] = [i for i in range(len(word1)+1)]
    for j in range(1, len(word2)+1):
        
        for i in range(1, len(word1)+1):
            if word1[i-1] == word2[j-1]:
                dp[j][i] = dp[j-1][i-1]
            else:
                dp[j][i] = min(dp[j-1][i-1], dp[j-1][i], dp[j][i-1]) + 1
    return dp
    
def solve(s, t):
    table = editDistance(s, t)
    i, j = len(t), len(s)
    operations = []
    print(table[-1][-1])
    while table[i][j] > 0:
        cur = table[i][j]
        replace = table[i-1][j-1]
        delete = table[i][j-1]
        insert = table[i-1][j]
        if insert < cur and insert <= delete and insert <= replace:
            operations.append('INSERT ' + str(i) + ' ' +t[i-1])
            i -= 1
        elif delete < cur and delete <= insert and delete <= replace:
            operations.append('DELETE ' + str(j))
            j -= 1
        elif replace < cur and replace <= insert and replace <= delete:
            operations.append('REPLACE ' + str(i)+' ' + t[i-1])
            i -= 1
            j -= 1
        else:
            i -= 1
            j -= 1
    for op in reversed(operations):
        print(op)
        
        
    
    # while i > 0 and j > 0:
    #     replace = dp
    
    
        
         
        

s = input()
t = input()
solve(s, t)