#!/usr/bin/python3

from dataclasses import dataclass
from functools import cache
from math import inf
from typing import Optional

# Jeden stav dynamického programování: pamatuje si cenu, předchůdce a posloupnost
# příkazů Nim-Vimu provedených v posledním kroku.
@dataclass
class State:
    cost: float
    steps: list[str]
    prev: Optional["State"]

    # Vytvoří nový stav: (pi,pj) jsou indexy předchůdce, steps seznam příkazů editoru
    # v posledním kroku.
    def __init__(self, pi: int, pj: int, steps: list[str]):
        self.prev = dp(pi, pj)
        self.steps = steps

        # Jaká je cena aktuálních příkazů?
        now_cost = sum(map(lambda s: s.startswith("2") or s.startswith("3"), self.steps))

        if pi == 0 and pj == 0:
            self.cost = now_cost
        elif self.prev is None:
            self.cost = inf
        else:
            self.cost = self.prev.cost + now_cost
    
    def print(self):
        if self.prev is not None:
            self.prev.print()
            print(*self.steps, sep="\n")

    def __lt__(self, o: "State"):
        return self.cost < o.cost


# Výpočet tabulky popisujeme rekruzivní funkcí, jejíž výsledky se kešují.
@cache
def dp(i, j) -> Optional[State]:
    if i < 0 or j < 0:
        return None

    best = State(-1, -1, [])
    if i >= 2:
        best = min(best, State(i-2, j, ["2x"]))
    if i >= 3:
        best = min(best, State(i-3, j, ["3x"]))
    if j >= 2:
        best = min(best, State(i, j-2, [f"2i{word2[j-2]}{word2[j-1]}"]))
    if j >= 3:
        best = min(best, State(i, j-3, [f"3i{word2[j-3]}{word2[j-2]}{word2[j-1]}"]))
    if i >= 1 and j >= 1:
        best = min(best, State(i-1, j-1, ["l"] if word1[i-1] == word2[j-1] else [f"2i{word2[j-1]}*", "h", "2x"]))
    if i >= 1 and j >= 1:
        best = min(best, State(i-1, j, ["2i**", "h", "h", "3x"]))
    if j >= 1:
        best = min(best, State(i, j-1, [f"3i{word2[j-1]}**", "h", "h", "2x"]))
    if i >= 2 and j >= 1:
        best = min(best, State(i-2, j-1, [f"2i{word2[j-1]}*", "h", "3x"]))
    if i >= 1 and j >= 2:
        best = min(best, State(i-1, j-2, [f"3i{word2[j-2]}{word2[j-1]}*", "h", "2x"]))

    return best
    

word1 = input()
word2 = input()
for i in range(len(word1)+1):
    for j in range(len(word2)+1):
        dp(i, j)
dp(len(word1), len(word2)).print()
print(":wq")