#include <string>
#include <vector>

using namespace std;

struct coordinate{
    int x;
    int y;
    coordinate() : y(0), x(0) {}
    coordinate(int c1, int c2) : y(c1), x(c2) {}
};

typedef struct coordinate coordinate;

long long solution(vector<string> grid) {
    long long answer = 0;
    coordinate p, p1, p2, siz;
    siz.x=0;
    siz.y=0;
    int i=0;
    
    //map 크기
    while(1){
        if(grid.size()==i || !grid[i++][0]){
            siz.y=i;
            break;
        }
    }
    i=0;
    while(1){
        if(grid[0].size()==i || !grid[0][i++]){
            siz.x=i;
            break;
        }
    }
    
    //눈덩이 위치
    for(i=0; i<siz.y; i++){
        for(int j=0; j<siz.x; j++){
            if(grid[i][j]=='o'){
                if(p1.x==0) p1.x=j;
                else p2.x=j;
                if(p1.y==0) p1.y=i;
                else p2.y=i;
                if(p1.x&&p2.x) break;
            }
        }
    }
    
    //공용 맵
    vector<vector<int>> map(siz.y, vector<int>(siz.x,0));
    vector<vector<coordinate>> list;
    int seed;
    int num;
    int ch;
    
    //영역 1
    vector<vector<int>> map1(siz.y, vector<int>(siz.x,0));
    list.resize(2,vector<coordinate>());
    list[0].push_back({p1.y, p1.x});
    int map1siz=1;
    seed=0;
    num=2;
    ch=1;
    map1[p1.y][p1.x]=1;
    map[p1.y][p1.x]+=1;
    while(ch){
        ch=0;
        for(i=0;i<list[seed].size();i++){
            p=list[seed][i];
            
            if(p.x+1<siz.x && grid[p.y][p.x+1]=='.' && map1[p.y][p.x+1]==0){
                map1[p.y][p.x+1]=num;
                map[p.y][p.x+1]+=1;
                list[(seed+1)%2].push_back({p.y, p.x+1});
                ch++;
            }
            
            if(p.x-1>=0 && grid[p.y][p.x-1]=='.' && map1[p.y][p.x-1]==0){
                map1[p.y][p.x-1]=num;
                map[p.y][p.x-1]+=1;
                list[(seed+1)%2].push_back({p.y, p.x-1});
                ch++;
            }
            
            if(p.y+1<siz.y && grid[p.y+1][p.x]=='.' && map1[p.y+1][p.x]==0){
                map1[p.y+1][p.x]=num;
                map[p.y+1][p.x]+=1;
                list[(seed+1)%2].push_back({p.y+1, p.x});
                ch++;
            }
            
            if(p.y-1>=0 && grid[p.y-1][p.x]=='.' && map1[p.y-1][p.x]==0){
                map1[p.y-1][p.x]=num;
                map[p.y-1][p.x]+=1;
                list[(seed+1)%2].push_back({p.y-1, p.x});
                ch++;
            }
        }
        map1siz+=ch;
        num++;
        list[seed].clear();
        seed=(seed+1)%2;
    }
    
    //영역 2
    vector<vector<int>> map2(siz.y, vector<int>(siz.x,0));
    list.resize(2,vector<coordinate>());
    list[0].push_back({p2.y, p2.x});
    int map2siz=1;
    seed=0;
    num=2;
    ch=1;
    map2[p2.y][p2.x]=1;
    map[p2.y][p2.x]+=2;
    while(ch){
        ch=0;
        for(i=0;i<list[seed].size();i++){
            p=list[seed][i];
            
            if(p.x+1<siz.x && grid[p.y][p.x+1]=='.' && map2[p.y][p.x+1]==0){
                map2[p.y][p.x+1]=num;
                map[p.y][p.x+1]+=2;
                list[(seed+1)%2].push_back({p.y, p.x+1});
                ch++;
            }
            
            if(p.x-1>=0 && grid[p.y][p.x-1]=='.' && map2[p.y][p.x-1]==0){
                map2[p.y][p.x-1]=num;
                map[p.y][p.x-1]+=2;
                list[(seed+1)%2].push_back({p.y, p.x-1});
                ch++;
            }
            
            if(p.y+1<siz.y && grid[p.y+1][p.x]=='.' && map2[p.y+1][p.x]==0){
                map2[p.y+1][p.x]=num;
                map[p.y+1][p.x]+=2;
                list[(seed+1)%2].push_back({p.y+1, p.x});
                ch++;
            }
            
            if(p.y-1>=0 && grid[p.y-1][p.x]=='.' && map2[p.y-1][p.x]==0){
                map2[p.y-1][p.x]=num;
                map[p.y-1][p.x]+=2;
                list[(seed+1)%2].push_back({p.y-1, p.x});
                ch++;
            }
        }
        map2siz+=ch;
        num++;
        list[seed].clear();
        seed=(seed+1)%2;
    }
    
    //최단거리 합
    p=p1;
    int minsum=1;
    while(1){
        ch=0;
        num=1000;
        if(p.x+1<siz.x && map2[p.y][p.x+1] && map2[p.y][p.x+1]<num){
            num=map2[p.y][p.x+1];
            ch=1;
        }

        if(p.x-1>=0 && map2[p.y][p.x-1] && map2[p.y][p.x-1]<num){
            num=map2[p.y][p.x-1];
            ch=2;
        }

        if(p.y+1<siz.y && map2[p.y+1][p.x] && map2[p.y+1][p.x]<num){
            num=map2[p.y+1][p.x];
            ch=3;
        }

        if(p.y-1>=0 && map2[p.y-1][p.x] && map2[p.y-1][p.x]<num){
            num=map2[p.y-1][p.x];
            ch=4;
        }
        if(ch==0) break;
        if(ch==1){
            p.x++;
        }
        if(ch==2){
            p.x--;
        }
        if(ch==3){
            p.y++;
        }
        if(ch==4){
            p.y--;
        }
        minsum++;
        if(p.x==p2.x && p.y==p2.y) break;
    }
    
    //최대 합
    int maxsum=0;
    for(i=0;i<siz.y;i++){
        for(int j=0;j<siz.x;j++){
            if(map[i][j]){
                maxsum++;
            }
        }
    }
    
    //최대 조건 1영역
    list.resize(2,vector<coordinate>());
    list[0].push_back({p1.y, p1.x});
    seed=0;
    num=2;
    ch=1;
    while(ch){
        ch=0;
        for(i=0;i<list[seed].size();i++){
            p=list[seed][i];
            
            if(p.x+1<siz.x && map[p.y][p.x+1]==1 && map1[p.y][p.x+1]>0){
                list[(seed+1)%2].push_back({p.y, p.x+1});
                ch++;
            }
            
            if(p.x-1>=0 && map[p.y][p.x-1]==1 && map1[p.y][p.x-1]>0){
                list[(seed+1)%2].push_back({p.y, p.x-1});
                ch++;
            }
            
            if(p.y+1<siz.y && map[p.y+1][p.x]==1 && map1[p.y+1][p.x]>0){
                list[(seed+1)%2].push_back({p.y+1, p.x});
                ch++;
            }
            
            if(p.y-1>=0 && map[p.y-1][p.x]==1 && map1[p.y-1][p.x]>0){
                list[(seed+1)%2].push_back({p.y-1, p.x});
                ch++;
            }
            
            if(ch>2){
                ch=0;
                break;
            }
        }
        map1[p.y][p.x]*=-1;
        num++;
        list[seed].clear();
        seed=(seed+1)%2;
    }
    
    //최대 조건 2영역
    list.resize(2,vector<coordinate>());
    list[0].push_back({p2.y, p2.x});
    seed=0;
    num=2;
    ch=1;
    while(ch){
        ch=0;
        for(i=0;i<list[seed].size();i++){
            p=list[seed][i];
            
            if(p.x+1<siz.x && map[p.y][p.x+1]==2 && map2[p.y][p.x+1]>0){
                list[(seed+1)%2].push_back({p.y, p.x+1});
                ch++;
            }
            
            if(p.x-1>=0 && map[p.y][p.x-1]==2 && map2[p.y][p.x-1]>0){
                list[(seed+1)%2].push_back({p.y, p.x-1});
                ch++;
            }
            
            if(p.y+1<siz.y && map[p.y+1][p.x]==2 && map2[p.y+1][p.x]>0){
                list[(seed+1)%2].push_back({p.y+1, p.x});
                ch++;
            }
            
            if(p.y-1>=0 && map[p.y-1][p.x]==2 && map2[p.y-1][p.x]>0){
                list[(seed+1)%2].push_back({p.y-1, p.x});
                ch++;
            }
            
            if(ch>2){
                ch=0;
                break;
            }
        }
        map2[p.y][p.x]*=-1;
        num++;
        list[seed].clear();
        seed=(seed+1)%2;
    }
    return num;
    return maxsum;
    return answer;
}