Problem:
Problem C: Emacs-like Editor

Emacs is a text editor which is widely used by many programmers.

The advantage of Emacs is that we can move a cursor without arrow keys and the mice. For example, the cursor can be moved right, left, down, and up by pushing f, b, n, p with the Control Key respectively. In addition, cut-and-paste can be performed without the mouse.

Your task is to write a program which simulates key operations in the Emacs-like editor. The program should read a text and print the corresponding edited text.

The text consists of several lines and each line consists of zero or more alphabets and space characters. A line, which does not have any character, is a blank line.

The editor has a cursor which can point out a character or the end-of-line in the corresponding line. The cursor can also point out the end-of-line in a blank line.

In addition, the editor has a buffer which can hold either a string (a sequence of characters) or a linefeed.

The editor accepts the following set of commands (If the corresponding line is a blank line, the word "the first character" should be "the end-of-line"):

a

Move the cursor to the first character of the current line.

e

Move the cursor to the end-of-line of the current line.

p

Move the cursor to the first character of the next upper line, if it exists.

If there is no line above the current line, move the cursor to the first character of the current line.

n

Move the cursor to the first character of the next lower line, if it exists.

If there is no line below the current line, move the cursor to the first character of the current line.

f

Move the cursor by one character to the right, unless the cursor points out the end-of-line.

If the cursor points out the end-of-line and there is a line below the current line, move the cursor to the first character of the next lower line. Otherwise, do nothing.

b

Move the cursor by one character to the left, unless the cursor points out the first character.

If the cursor points out the first character and there is a line above the current line, move the cursor to the end-of-line of the next upper line. Otherwise, do nothing.

d

If the cursor points out a character, delete the character (Characters and end-of-line next to the deleted character are shifted to the left).

If the cursor points out the end-of-line and there is a line below, the next lower line is appended to the end-of-line of the current line (Lines below the current line are shifted to the upper).
Otherwise, do nothing.

k

If the cursor points out the end-of-line and there is a line below the current line, perform the command d mentioned above, and record a linefeed on the buffer.

If the cursor does not point out the end-of-line, cut characters between the cursor (inclusive) and the end-of-line, and record them on the buffer. After this operation, the cursor indicates the end-of-line of the current line.

y

If the buffer is empty, do nothing.

If the buffer is holding a linefeed, insert the linefeed at the cursor. The cursor moves to the first character of the new line.

If the buffer is holding characters, insert the characters at the cursor. The cursor moves to the character or end-of-line which is originally pointed by the cursor.

The cursor position just after reading the text is the beginning of the first line, and the initial buffer is empty.

Input

The input consists of only one data-set which includes two parts. The first part gives a text consisting of several lines. The end of the text is indicated by a line (without quotes):

"END_OF_TEXT"

This line should not be included in the text.

Next part gives a series of commands. Each command is given in a line. The end of the commands is indicated by a character '-'.

Output

For the input text, print the text edited by the commands.

Constraints

The number of lines in the text given as input ≤ 10

The number of characters in a line given as input ≤ 20

The number of commands ≤ 300

The maximum possible number of lines in the text during operations ≤ 100

The maximum possible number of characters in a line during operations ≤ 1000

Sample Input

hyo
ni
END_OF_TEXT
f
d
f
f
k
p
p
e
y
a
k
y
y
n
y
-

Output for the Sample Input

honihoni
honi

Solution in Ruby (judge verdict: Wrong Answer)

END_OF_TEXT = 'END_OF_TEXT'
END_OF_COMMAND = '-'

$text = []
$commands = []

def input_line s_end
    return false if ! ( s = gets )
    s = s.strip
    s == s_end ? false : s
end

def input_until s
    ->() {
        res = []
        while line = input_line(s) do
            res.push(line)
        end
        res.empty? ? false : res
    }
end

$input_text = input_until END_OF_TEXT
$input_commands = input_until END_OF_COMMAND

def input
    if $text = $input_text.call
        if $commands = $input_commands.call
            return true
        end
    end
    return false
end

class Editor
    def initialize
        @r = 0
        @c = 0
        @buffer = ""
    end

    def check_cursor_leftmost
        @c == 0
    end

    def check_cursor_rightmost
        @c == $text[@r].length
    end

    def has_prev_line
        @r - 1 >= 0
    end

    def has_next_line
        @r + 1 < $text.length
    end

    def delete_line k
        $text[k, 1] = []
    end

    def delete_letter k
        $text[@r][k, 1] = '' 
    end

    def move_to_leftmost 
        @c = 0
    end

    def move_to_rightmost
        @c = $text[@r].length
    end

    def move_to_up
        @r -= 1
    end

    def move_to_down
        @r += 1
    end

    def move_to_left k = 1
        @c -= k
    end

    def move_to_right k = 1
        @c += k
    end

    def command_a
        move_to_leftmost
    end

    def command_e
        move_to_rightmost
    end

    def command_p
        move_to_up if has_prev_line
        move_to_leftmost
    end

    def command_n
        move_to_down if has_next_line
        move_to_leftmost
    end

    def command_f
        if check_cursor_rightmost
            move_to_down if has_next_line
            move_to_leftmost
        else
            move_to_right
        end
    end

    def command_b
        if check_cursor_leftmost
            move_to_up if has_prev_line
            move_to_rightmost
        else
            move_to_left
        end
    end

    def command_d
        if check_cursor_rightmost
            if has_next_line
                $text[@r] += $text[@r+1]
                delete_line @r + 1
            end
        else
            delete_letter @c
        end
    end

    def command_k
        if check_cursor_rightmost
            if has_next_line
                $text[@r] += $text[@r+1]
                delete_line @r + 1
                @buffer = '\n'
            end
        else
            @buffer = $text[@r][@c..$text[@r].length-1]
            $text[@r] = $text[@r][0, @c]
        end
    end

    def command_y
        if @buffer == '\n'
            tmp = $text[@r][@c..$text[@r].length-1]
            $text[@r] = $text[@r][0, @c]
            $text[@r, 0] = tmp
            move_to_down
            move_to_leftmost
        elsif @buffer != ''
            $text[@r][@c, 0] = @buffer
            move_to_right @buffer.length
        end
    end

    def command s
        case s
        when "a"
            command_a
        when "e"
            command_e
        when "p"
            command_p
        when "n"
            command_n
        when "f"
            command_f
        when "b"
            command_b
        when "d"
            command_d
        when "k"
            command_k
        when "y"
            command_y
        end
    end
end

def execute_command s
    $e.command s
end

def solve
    $e = Editor.new
    $commands.each {|cmd|
        execute_command cmd
    }
end

def output
    $text.map {|s| puts s}
end

while input
    solve
    output
end