#include <algorithm>
#include <bitset>
#include <iostream>
#include <iterator>
#include <numeric>
#include <sstream>
#include <string>
#include <vector>

class HexPic {
protected:
    std::string hex_to_string(unsigned int value) {
        return std::bitset<8>(value).to_string();
    }

    template <typename Iter>
    void binary_to_stream(Iter begin, Iter end, std::ostream& stream) const {
        char on = display_on_;
        char off = display_off_;

        if (inverted_) std::swap(on, off);

        std::string temp = std::accumulate(begin, end, std::string(""),
                                           [&](std::string& res, char ch) {
                                               return res += std::string(static_cast<int>(magnification_), (ch == '0' ? off : on));
                                           });

        for (int i = 0; i < magnification_; ++i) {
            stream << temp << '\n';
        }
    }


public:
    enum RotateDirection { top, right, bottom, left };

    friend HexPic::RotateDirection& operator++(HexPic::RotateDirection& r) {
        if (static_cast<int>(r) == 3) return r = HexPic::RotateDirection(0);
        return r = HexPic::RotateDirection((static_cast<int>(r) + 1));
    }

    friend HexPic::RotateDirection& operator--(HexPic::RotateDirection& r) {
        if (static_cast<int>(r) == 0) return r = HexPic::RotateDirection(3);
        return r = HexPic::RotateDirection((static_cast<int>(r) - 1));
    }

    explicit HexPic() : inverted_{false}, magnification_{1.0},
                        direction_{RotateDirection::top},
                        display_on_{'X'}, display_off_{'.'} {}

    void add_hexrow(const unsigned int hexval) {
        bitmap_.push_back(hex_to_string(hexval));
    }

    void draw(std::ostream& stream) const {
        switch (direction_) {
            case top: {
                for (const auto& row : bitmap_) {
                    binary_to_stream(row.begin(), row.end(), stream);
                }
                break;
            }
            case right: {
                std::vector<std::string> columns(bitmap_[0].size());

                std::for_each(bitmap_.rbegin(),
                              bitmap_.rend(),
                              [&](const std::string& row) {
                                  std::transform(row.begin(),
                                                 row.end(),
                                                 columns.begin(),
                                                 columns.begin(),
                                                 [](char ch, std::string str) {
                                                     return str + ch;
                                                 });
                              });

                for (const auto& col : columns) {
                    binary_to_stream(col.begin(), col.end(), stream);
                }

                break;
            }
            case bottom: {
                std::for_each(bitmap_.rbegin(),
                              bitmap_.rend(),
                              [&](const std::string& row) {
                                  binary_to_stream(row.rbegin(), row.rend(), stream);
                              });
                break;
            }
            case left: {
                std::vector<std::string> columns(bitmap_[0].size());

                std::for_each(bitmap_.begin(),
                              bitmap_.end(),
                              [&](const std::string& row) {
                                  std::transform(row.rbegin(),
                                                 row.rend(),
                                                 columns.begin(),
                                                 columns.begin(),
                                                 [](char ch, std::string str) {
                                                     return str + ch;
                                                 });
                              });

                for (const auto& col : columns) {
                    binary_to_stream(col.begin(), col.end(), stream);
                }

                break;
            }
        }

        stream << '\n';
    }

    void rotate_cw() {
        ++direction_;
    }

    void rotate_ccw() {
        --direction_;
    }

    void zoom(double multiplier) {
        magnification_ = std::max(1.0, magnification_ * multiplier);
    }

    void invert_display_bits() {
        inverted_ = !inverted_;
    }

    friend std::istream& operator>>(std::istream& stream, HexPic& pic) {
        HexPic temp;
        std::string input;
        std::getline(stream, input);
        std::istringstream iss(input);

        unsigned int value;
        while (iss >> std::hex >> value) {
            temp.add_hexrow(value);
        }

        pic = temp;
        return stream;
    }

private:
    std::vector<std::string> bitmap_;
    RotateDirection direction_;
    char display_off_;
    char display_on_;
    bool inverted_;
    double magnification_;
};

int main() {
    std::vector<HexPic> pics((std::istream_iterator<HexPic>(std::cin)),
                             std::istream_iterator<HexPic>());

    for (auto& pic : pics) {
        pic.draw(std::cout);

        pic.zoom(2);
        pic.rotate_cw();
        pic.zoom(2);
        pic.invert_display_bits();
        pic.zoom(0.5);
        pic.draw(std::cout);
    }
}