#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;
        }
    }
    
    p1.x=-1;
    p1.y=-1;
    
    //눈덩이 위치
    for(i=0; i<siz.y; i++){
        for(int j=0; j<siz.x; j++){
            if(grid[i][j]=='o'){
                if(p1.x==-1) p1.x=j;
                else p2.x=j;
                if(p1.y==-1) 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;
    long long num;
    int ch;
    int ifcase=-1;
    int casech;
    int casech1;
    
    //최대 합
    int maxsum=0;
    
    //영역 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];
            casech=0;
            if(p.x+1<siz.x && grid[p.y][p.x+1]=='.'){
                if(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++;
                }
                casech++;
            }
            
            if(p.x-1>=0 && grid[p.y][p.x-1]=='.'){
                if(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++;
                }
                casech++;
            }
            
            if(p.y+1<siz.y && grid[p.y+1][p.x]=='.'){
                if(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++;
                }
                casech++;
            }
            
            if(p.y-1>=0 && grid[p.y-1][p.x]=='.'){
                if(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++;
                }
                casech++;
            }
            if(casech>2 && ifcase==-1)
                ifcase=num;
        }
        map1siz+=ch;
        num++;
        list[seed].clear();
        seed=(seed+1)%2;
    }
    maxsum=map1siz+1;
    
    //영역 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;
    casech1=-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];
            casech=0;
            if(p.x+1<siz.x && grid[p.y][p.x+1]=='.'){
                if(map2[p.y][p.x+1]==0){
                    if(!map[p.y][p.x+1])
                        maxsum++;
                    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++;
                }
                casech++;
            }
            
            if(p.x-1>=0 && grid[p.y][p.x-1]=='.'){
                if(map2[p.y][p.x-1]==0){
                    if(!map[p.y][p.x-1])
                        maxsum++;
                    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++;
                }
                casech++;
            }
            
            if(p.y+1<siz.y && grid[p.y+1][p.x]=='.'){
                if(map2[p.y+1][p.x]==0){
                    if(!map[p.y+1][p.x])
                        maxsum++;
                    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++;
                }
                casech++;
            }
            
            if(p.y-1>=0 && grid[p.y-1][p.x]=='.'){
                if(map2[p.y-1][p.x]==0){
                    if(!map[p.y-1][p.x])
                        maxsum++;
                    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++;
                }
                casech++;
            }
            if(casech>2 && casech1==-1)
                casech1=num;
        }
        map2siz+=ch;
        num++;
        list[seed].clear();
        seed=(seed+1)%2;
    }
    
    if(ifcase!=-1){
        if(casech1!=-1){
            if(casech1<ifcase)
                ifcase=casech1;
        }
    }else{
        ifcase=casech1;
    }
    
    //최단거리 합
    p=p1;
    int minsum=1;
    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];
    }

    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];
    }

    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];
    }

    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];
    }
    minsum = num+1;
    
    //계산
    vector<vector<int>> chmaplist(maxsum+1,vector<int>(2,0));
    if(map2siz>map1siz){
        answer=map1siz;
        map2siz=map1siz;
        map1siz=answer;
    }
    answer=0;
    int min,max;    
    if(ifcase==-1){
        for(i=1;i<=map1siz;i++){
            min = minsum-i > 1 ? minsum-i : 1;
            max = maxsum-i < map2siz ? maxsum-i : map2siz;
            max = max > i ? i : max;
            
            answer += max-min >= 0 ? max-min+1 : 0;
        }
    }else{
        for(i=1;i<maxsum;i++){
            min = minsum-i > 1 ? minsum-i : 1;
            //max = maxsum-i < map2siz ? maxsum-i : map2siz;
            
            max = maxsum-1 > i ? i : maxsum-1;
            
            answer += max-min >= 0 ? max-min+1 : 0;
        }
        /*for(i=ifcase-1;i<maxsum;i++){
            num=maxsum-i-1>map2siz?map2siz:maxsum-i-1;
            seed=minsum-i-2>0?minsum-i-2:0;
            for(int j=seed;j<num;j++){
                if(!chmaplist[i][j] && !chmaplist[j][i])
                answer++;
                chmaplist[i][j]=1;
            }
        }*/
    }
    return answer;
}