#include <bits/stdc++.h>
using namespace std;

// 检查在当前子集中 cur 中加入 x 是否依然满足：
// 对于任意 a,b in cur ∪ {x}，若 a+b 为偶，则 (a+b)/2 不在 cur ∪ {x}。
// 只需要检查与 x 相关的组合即可。
bool validToAdd(int x, const vector<int>& cur) {
    // 检查 x 与已有的每个元素 y：
// 若 (x+y) 为偶，则 (x+y)/2 必不在 cur中。
    for (int y : cur) {
        if ((x + y) % 2 == 0) {
            int mid = (x + y) / 2;
            // 检查 cur 中是否有 mid
            if(find(cur.begin(), cur.end(), mid) != cur.end())
                return false;
        }
    }
    // 检查 x 不能成为已有两个数的中点
    int sz = cur.size();
    for (int i = 0; i < sz; i++) {
        for (int j = i+1; j < sz; j++) {
            if ((cur[i] + cur[j]) % 2 == 0 && (cur[i] + cur[j]) / 2 == x)
                return false;
        }
    }
    return true;
}

// 回溯搜索，在 candidates 数组中寻找一个最大子集（存储为 vector<int>），
// 该子集满足上述“无三项等差”性质
void dfs(int pos, const vector<int>& candidates, vector<int>& cur, vector<int>& best) {
    int n = candidates.size();
    if(pos == n){
        if(cur.size() > best.size()){
            best = cur;
        }
        return;
    }
    // 剪枝：剩余候选数加上当前数目不可能超过 best 的大小时可直接返回
    if(cur.size() + (n - pos) <= best.size()){
        return;
    }
    // 选取当前候选数
    int x = candidates[pos];
    if(validToAdd(x, cur)){
        cur.push_back(x);
        dfs(pos+1, candidates, cur, best);
        cur.pop_back();
    }
    // 不选取当前候选数
    dfs(pos+1, candidates, cur, best);
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    string s;
    cin >> s;
    int N = s.size();
    if(N==1){
        cout<<"1\n#\n";
        return 0;
    }
    // S0：固定已有的灯（'#'）位置（1-indexed）
    vector<bool> fixedLamp(N+1, false);
    for(int i = 0; i < N; i++){
        if(s[i]=='#'){
            fixedLamp[i+1] = true;
        }
    }

    // 对于非固定位置，我们分别收集奇数和偶数候选
    vector<int> oddCandidates, evenCandidates;
    for(int i = 1; i <= N; i++){
        if(!fixedLamp[i]){
            if(i % 2 == 1)
                oddCandidates.push_back(i);
            else
                evenCandidates.push_back(i);
        }
    }

    // 对每个候选集合，用回溯找出最大无三项等差子集 T
    vector<int> bestOdd, bestEven, cur;
    dfs(0, oddCandidates, cur, bestOdd);
    cur.clear();
    dfs(0, evenCandidates, cur, bestEven);

    // 选择使 T 最大的那一组（如果平手任选）
    bool useOdd = (bestOdd.size() >= bestEven.size());
    // chosenT: 存放所选候选集合中的 indices（它们将没有灯放置）
    unordered_set<int> chosenT;
    if(useOdd){
        for (int x : bestOdd)
            chosenT.insert(x);
    } else {
        for (int x : bestEven)
            chosenT.insert(x);
    }

    // 构造最终放灯的位置 S (1-indexed)：
    // 固定已有的灯位置固定；其他位置：
    // 如果该位置非固定且其奇偶性与所选集合匹配且出现在 chosenT 中，则不放灯（'.')；
    // 否则放灯('#').
    string ans(N, '.');
    int lampCount = 0;
    for (int i = 1; i <= N; i++){
        if(fixedLamp[i]) {
            ans[i-1] = '#';
            lampCount++;
        } else {
            // 判断当前 i 是否属于候选的那一组
            bool inChosenGroup = false;
            if(useOdd && (i % 2 == 1)){
                if(chosenT.count(i)) inChosenGroup = true;
            }
            if(!useOdd && (i % 2 == 0)){
                if(chosenT.count(i)) inChosenGroup = true;
            }
            if(inChosenGroup){
                ans[i-1] = '.';
            } else {
                ans[i-1] = '#';
                lampCount++;
            }
        }
    }

    // 输出：第一行输出最终总灯数（包括固定的）
    cout << lampCount << "\n" << ans << "\n";
    return 0;
}