/**
 * code generated by JHelper
 * More info: https://github.com/AlexeyDmitriev/JHelper
 * @author aryssoncf
 */



// Taken from: https://github.com/bqi343/USACO/blob/master/Implementations/content/contest/templateShort.cpp

#include <utility>
#include <vector>
#include <random>
#include <chrono>
#include <cassert>
#include <set>
#include <queue>
#include <map>
#include <numeric>
#include <algorithm>
#include <iostream>
#include <unordered_map>
#include <bitset>
#include <iomanip>
#include <complex>
#include <stack>
#include <array>
#include <unordered_set>
#include <climits>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef double db;
typedef string str;

typedef pair<int, int> pii;

typedef vector<int> vi;
typedef vector<ull> vul;
typedef vector<ll> vl;
typedef vector<pii> vpii;

#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
#define ROF(i,a,b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i,a) ROF(i,0,a)
#define trav(a,x) for (auto& a: x)

#define sz(x) (int)x.size()
#define all(x) begin(x), end(x)
#define rsz resize

#define mp make_pair
#define pb push_back
#define f first
#define s second

const int MOD = 1e9+7; // 998244353; // = (119<<23)+1
const int MX = 2e5+5;

template<class T> bool ckmin(T& a, const T& b) {
    return a > b ? a = b, 1 : 0; }
template<class T> bool ckmax(T& a, const T& b) {
    return a < b ? a = b, 1 : 0; }

mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());


//
// Created by aryssoncf on 28/10/2019.
//

#include <type_traits>


#include <iterator>


template <typename T>
constexpr auto hasBegin(int) -> decltype(std::begin(std::declval<T>()), true) {
    return true;
}

constexpr bool hasBegin(...) {
    return false;
}

template <typename T>
using IsContainer = std::integral_constant<bool, hasBegin<T>(0)>;


#ifndef JHELPER_EXAMPLE_PROJECT_IO_HPP
#define JHELPER_EXAMPLE_PROJECT_IO_HPP

#endif //JHELPER_EXAMPLE_PROJECT_IO_HPP

template<typename T>
std::istream &operator>>(std::istream &is, std::vector<T> &vec) {
    for (T &element: vec) {
        is >> element;
    }
    return is;
}

template<typename T, typename U>
std::istream &operator>>(std::istream &is, std::pair<T, U> &p) {
    is >> p.first;
    is >> p.second;
    return is;
}

template <class X, class Y>
std::ostream & operator << (std::ostream & os, std::pair <X, Y> const& p) {
    return os << p.first << " " << p.second;
}

template <class Ch, class Tr, class Container>
std::basic_ostream <Ch, Tr> & operator << (std::basic_ostream <Ch, Tr>& os, Container const& x) {
    bool first = true;
    for(auto& y : x) {
        if (first) {
            first = false;
        } else {
            os << " ";
        }
        os << y;
    }
    return os;
}








using namespace std;

template <typename T>
class VectorVectorBaseGraph {
public:
    using Edge = T;
    using Vertex = std::size_t;

    explicit VectorVectorBaseGraph(std::size_t n=0): g(n) {
    }

    template <typename U>
    using Collection = std::vector<U>;

    template <typename U>
    Collection<U> getCollection(const U& defaultValue) const {
        return Collection<U>(g.size(), defaultValue);
    }

    std::vector<std::size_t> vertices() const {
        std::vector<std::size_t> order(g.size());
        std::iota(order.begin(), order.end(), 0);
        return order;
    }

    const std::vector<Edge>& outgoingEdges(Vertex vertex) const {
        return g[vertex];
    }

    vector<Vertex> toposort() {
        int n = g.size();
        vector<bool> used(n);
        vector<Vertex> order;
        for (int i = 0; i < n; i++)
            if (!used[i])
                dfs(used, order, i);
        reverse(order.begin(), order.end());
        return order;
    }

    virtual Vertex endOfEdge(Vertex, Edge) const = 0;

protected:
    std::vector<std::vector<Edge>> g;

private:
    void dfs(vector<bool> &used, vector<Vertex> &order, int u) {
        used[u] = true;
        for (Edge ed : outgoingEdges(u)) {
            Vertex v = endOfEdge(u, ed);
            if (!used[v])
                dfs(used, order, v);
        }
        order.push_back(u);
    }
};


class SimpleGraph: public VectorVectorBaseGraph<std::size_t> {
public:
    explicit SimpleGraph(std::size_t n=0): VectorVectorBaseGraph(n) {}

    Vertex endOfEdge(Vertex, Edge edge) const {
        return edge;
    }

    void addEdge(Vertex from, Vertex to) {
        g[from].push_back(to);
    }
};





template <typename Graph>
std::vector<int> bfsDistances(const Graph& graph, const typename Graph::Vertex& from) {
    auto result = graph.getCollection(-1);
    std::queue<typename Graph::Vertex> q;
    q.push(from);
    result[from] = 0;
    while (!q.empty()) {
        const auto& v = q.front();
        for (const auto& e: graph.outgoingEdges(v)) {
            const auto& to = graph.endOfEdge(v, e);
            if (result[to] == -1) {
                result[to] = result[v] + 1;
                q.push(to);
            }
        }
        q.pop();
    }
    return result;
}


using namespace std;

class DGridRepainting {

    const vpii DIRS = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}};

public:
	void solve(std::istream& in, std::ostream& out) {
        int h, w;
        in >> h >> w;
        vector<str> grid(h);
        in >> grid;
        SimpleGraph graph(h * w);
        int cw = 0;
        FOR(i, 0, h) {
            FOR(j, 0, w) {
                trav(dir, DIRS) {
                    int i2 = i + dir.f, j2 = j + dir.s;
                    if (i2 >= 0 and i2 < h and j2 >= 0 and j2 < w and grid[i2][j2] == '.') {
                        graph.addEdge(i * w + j, i2 * w + j2);
                    }
                }
                cw += grid[i][j] == '.';
            }
        }
        int dist = bfsDistances(graph, 0).back(), res = dist == -1 ? -1 : cw - dist - 1;
        out << res << '\n';
	}

	void setup() {}
};


int main() {
    std::ios_base::sync_with_stdio(false);
	DGridRepainting solver;
    solver.setup();
	std::istream& in(std::cin);
	std::ostream& out(std::cout);
	in.tie(nullptr);
    out << std::fixed;
    out.precision(20);
	solver.solve(in, out);
	return 0;
}


Measured memory_bytes: 3788