Problem: jfen

There is a one-person game to play on the H × W board. This game is a game to move 0 or 1 balls in each cell. You were playing this game and found it difficult to move the ball accurately from cell to cell because the ball is so round. So you decided to make a robot that would move the ball as instructed. Here, the notation (y, x) is used to represent the cell. This represents the cell in the xth column of the yth row.

Instructions to the robot are given by the four integers a, b, c, d. This means moving the ball at (a, b) to (c, d). At this time, it is guaranteed that the ball exists in (a, b) and does not exist in (c, d).

The state of the board is expressed by the following notation called "jfen".


[Data in the first line] / [Data in the second line] /.../ [Data in the H line]

This notation is a slash-separated concatenation of data representing each line on the board. The data in each row is represented by a character string, and the state of the cells in the 1st to Wth columns is described in order from the left. This string is represented by a number and the letter'b', where the integer represented by the number represents the number of consecutive blank cells and'b' represents the cell in which the ball resides. Here, integers must not be consecutive in the data of each row. Also, the sum of the integers written in the data of each line and the sum of the number of'b'are always W.

As an example, consider the following board surface condition. A blank cell is represented by a'.', And a cell in which the ball exists is represented by a'b'. The j character from the left of the i-th row in this example represents the state of the cell in the j-th column of the i-th row on the board.


....
.b.b
....


The above board is expressed in jfen as follows.


4 / 1b1b / 4

Create a program that outputs the board surface after the robot moves the ball when the robot is given the current board surface state and a command to move one ball. At this time, output the board surface in jfen notation.

Input

The input consists of multiple datasets. Each dataset has the following format.

> S
> a b c d

Each dataset consists of two lines, and the first line is given the jfen-formatted string S, which represents the state of the board. Here, the size of the board satisfies 2 ≤ W and H ≤ 9. Instructions to the robot are given to the following lines. This represents an instruction to move the ball at (a, b) to (c, d). The end of the input is represented by #.

Output

The output is one line of character string that expresses the state of the board after executing the instruction for each data set in jfen notation. There must be no other characters on the output line.

Sample Input


b1 / 1b
1 1 1 2
b5 / bbbbbb
2 4 1 4
b2b2b / 7
1 4 2 4


Output for Sample Input


1b / 1b
b2b2 / bbb1bb
b5b / 3b3


The initial state of the first input is as follows.


b.
.b


Since the ball of (1,1) is moved to (1,2), the board surface after the command is as follows.


.b
.b






Example

Input

b1/1b
1 1 1 2
b5/bbbbbb
2 4 1 4
b2b2b/7
1 4 2 4
#


Output

1b/1b
b2b2/bbb1bb
b5b/3b3

Solution (in CPP):

Solution:
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <cstring>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <queue>
#include <deque>
#include <stack>
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <numeric>
#include <functional>
#include <cctype>
#include <list>
#include <limits>
#include <cassert>
//#include <boost/multiprecision/cpp_int.hpp>

const double EPS = (1e-10);


using namespace std;
using Int = long long;
//using namespace boost::multiprecision;

const Int MOD = 1000000007;

long long mod_pow(long long x, long long n) {
    long long res = 1;
    for(int i = 0;i < 60; i++){
        if(n >> i & 1) res = res * x % MOD;
        x = x * x % MOD;
    }
    return res;
}

template<typename T>
T gcd(T a, T b) {
    return b != 0 ? gcd(b, a % b) : a;
}

template<typename T>
T lcm(T a, T b) {
    return a * b / gcd(a, b);
}

void fast_input() {
    cin.tie(0);
    ios::sync_with_stdio(false);
}
vector<vector<int>> jtof(string S) {
    S.push_back('/');
    vector<vector<int>> ret;
    vector<int> tmp;
    for (int i = 0; i < S.length(); i++) {
        if (S[i] == 'b') {
            tmp.push_back(0);
        } else if (S[i] == '/') {
            ret.push_back(tmp);
            tmp.clear();
        } else {
            int num = (int)(S[i] - '0');
            for (int j = 0; j < num; j++) {
                tmp.push_back(1);
            }
        }
    }
    return ret;
}

string ftoj(vector<vector<int>> field) {
    string ret;
    for (int i = 0; i < field.size(); i++) {
        int cnt = 0;
        for (int j = 0; j < field[i].size(); j++) {
            if (field[i][j] == 1) {
                cnt++;
            } else if (field[i][j] == 0){
                if (cnt) ret.push_back('0' + cnt);
                cnt = 0;
                ret.push_back('b');
            }
            if (field[i].size() - 1 == j) {
                if (cnt) ret.push_back('0' + cnt);
                ret.push_back('/');
            }
        }
    }
    return ret;
}


string solve(string S) {
    vector<vector<int>> field = jtof(S);
    int a, b, c, d; cin >> a >> b >> c >> d;
    a--, b--, c--, d--;
    field[a][b] = 1;
    field[c][d] = 0;
    string ret = ftoj(field);
    return ret;
}

int main(void) {
    string S;
    vector<string> ans;
    while (1) {
        cin >> S;
        if (S[0] == '#') break;
        ans.push_back(solve(S));
    }
    for (auto &i : ans) {
        for (int j = 0; j < i.length() - 1; j++) {
            if (j != i.length() - 2) cout << i[j];
            else cout << i[j] << endl;
        }
    }
}