HA30_EGE(4)

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

class NumberTransformer {
private:
    static const int MAX_NUMBER = 10000;
    bool visited[MAX_NUMBER];
    int prev[MAX_NUMBER];

    bool is_valid(int number) {
        if (number < 1000 || number >= MAX_NUMBER)
            return false;
        int n = number;
        while (n > 0) {
            int digit = n % 10;
            if (digit == 0)
                return false;
            n /= 10;
        }
        return true;
    }

    vector<int> get_neighbors(int number) {
        vector<int> neighbors;
        int digits[4];
        int n = number;
        for (int i = 3; i >= 0; --i) {
            digits[i] = n % 10;
            n /= 10;
        }

        // Операция 1: Увеличение первой цифры на 1 (если не 9)
        if (digits[0] < 9) {
            int new_digits[4];
            for (int i = 0; i < 4; ++i) new_digits[i] = digits[i];
            new_digits[0] += 1;
            int new_number = new_digits[0]*1000 + new_digits[1]*100 + new_digits[2]*10 + new_digits[3];
            if (is_valid(new_number))
                neighbors.push_back(new_number);
        }

        // Операция 2: Уменьшение последней цифры на 1 (если не 1)
        if (digits[3] > 1) {
            int new_digits[4];
            for (int i = 0; i < 4; ++i) new_digits[i] = digits[i];
            new_digits[3] -= 1;
            int new_number = new_digits[0]*1000 + new_digits[1]*100 + new_digits[2]*10 + new_digits[3];
            if (is_valid(new_number))
                neighbors.push_back(new_number);
        }

        // Операция 3: Циклический сдвиг вправо
        int right_rotated_digits[4];
        right_rotated_digits[0] = digits[3];
        right_rotated_digits[1] = digits[0];
        right_rotated_digits[2] = digits[1];
        right_rotated_digits[3] = digits[2];
        int right_rotated_number = right_rotated_digits[0]*1000 + right_rotated_digits[1]*100 + right_rotated_digits[2]*10 + right_rotated_digits[3];
        if (is_valid(right_rotated_number))
            neighbors.push_back(right_rotated_number);

        // Операция 4: Циклический сдвиг влево
        int left_rotated_digits[4];
        left_rotated_digits[0] = digits[1];
        left_rotated_digits[1] = digits[2];
        left_rotated_digits[2] = digits[3];
        left_rotated_digits[3] = digits[0];
        int left_rotated_number = left_rotated_digits[0]*1000 + left_rotated_digits[1]*100 + left_rotated_digits[2]*10 + left_rotated_digits[3];
        if (is_valid(left_rotated_number))
            neighbors.push_back(left_rotated_number);

        return neighbors;
    }

public:
    NumberTransformer() {
        for (int i = 1000; i < MAX_NUMBER; ++i) {
            visited[i] = false;
            prev[i] = -1;
        }
    }

    void BFS(int start, int target) {
        queue<int> q;
        visited[start] = true;
        q.push(start);

        while (!q.empty()) {
            int current = q.front();
            q.pop();

            if (current == target)
                return;

            vector<int> neighbors = get_neighbors(current);
            for (size_t i = 0; i < neighbors.size(); ++i) {
                int next = neighbors[i];
                if (!visited[next]) {
                    visited[next] = true;
                    prev[next] = current;
                    q.push(next);
                }
            }
        }
    }

    vector<int> get_path(int start, int target) {
        vector<int> path;
        int current = target;
        while (current != -1) {
            path.push_back(current);
            if (current == start)
                break;
            current = prev[current];
        }
        // Разворачиваем путь
        vector<int> reversed_path;
        for (int i = path.size() - 1; i >= 0; --i)
            reversed_path.push_back(path[i]);
        return reversed_path;
    }
};

int main() {
    int start, target;
    cin >> start >> target;

    NumberTransformer transformer;
    transformer.BFS(start, target);

    vector<int> path = transformer.get_path(start, target);

    cout << path.size() << endl;
    for (size_t i = 0; i < path.size(); ++i) {
        cout << path[i] << endl;
    }

    return 0;
}