#include <iostream>
#include <vector>



bool isEven(int x){
    return (x%2)==0;
}

// pozice = index ve stringu
std::vector<int> getHashPos(){
    std::string line;
    std::getline(std::cin, line );
    size_t x = std::stoi(line); //how many lines does the matrix have
    std::vector<int> hashpos(x);
    for(size_t i = 0; i<x; i++){ //for lines
        std::getline(std::cin, line );
        for(size_t j = 0; j< line.size(); j++){
            if(line[j] == '#'){
                //std::cout<<j<<std::endl;
                //std::cout<<line<<std::endl;
                hashpos[i]=j;
                break;
            }
        }
    }
    return hashpos;
}

int unConstantine(std::vector<int> hashpos){

    size_t cur_idx = 0;
    int n = 1;
    while(cur_idx + 1 < hashpos.size()) {
        size_t pos_cur = hashpos[cur_idx];
        size_t pos_next = hashpos[cur_idx + 1];
        if (pos_next < pos_cur) {
            n = (2 * n) + 1;
        } else {
            n *= 2;
        }
        cur_idx++;
        //std::cout << n << std::endl;
    }
    return n;
}

void printOutput(int nLines, int lineW, int CNum, int startPos){
    int curNum = CNum;  // součet
    std::cout << nLines;
    std::cout << std::endl;
    std::vector<char*> matrix(nLines);
    int cur = startPos;
    for(int i = nLines-1; i >= 0; i--){
        matrix[i]=(char*)malloc(lineW * sizeof(char));
        std::cerr << "Line: " << i << std::endl;
        for(int j = 0; j<lineW; j++){
            std::cerr << cur << std::endl;
            if(j == cur){
                matrix[i][j] = '#';
            }else {
                matrix[i][j] = '.';
            }
        }
        if(curNum%2 == 0){
            cur--;
        } else {
            cur++;
        }
        curNum /= 2;

    }
    for (auto s : matrix){
        std::cout << s << std::endl;
        free(s);
    }

    return;
}

int main() {

    std::vector<int> hashpos1, hashpos2;

    hashpos1 = getHashPos();

    hashpos2 = getHashPos();

//    for(size_t i = 0; i<hashpos1.size(); i++){
//        std::cout<< hashpos1[i] << " ";
//    }
//    std::cout <<'\n';
//
//    for(size_t i = 0; i<hashpos2.size(); i++){
//        std::cout<< hashpos2[i] << " ";
//    }
//    std::cout <<'\n';

    int a = unConstantine(hashpos1);
    int b = unConstantine(hashpos2);

    std::cerr<< a+b<<std::endl;
    int res = a+b;
    int index = 0;
    int inmin = 0;
    int inmax = 0;
    int cnt = 0;
    while(res!=0){
      if(isEven(res)){
          index--;
          inmin = std::min(index, inmin);
      }
      else{
          index++;
          inmax = std::max(index, inmax);
      }
      cnt++;
      res= res/2;
    }
    //std::cout<< "matwidth = "<<inmax-inmin<<std::endl;
    int matwidth = inmax-inmin+1;
    printOutput(cnt, matwidth, a+b, -inmin);

    return 0;
}