import java.io.*;
import java.util.*;

/**
 * Made by egor https://github.com/chermehdi/egor.
 *
 * @author Azuz 
 *
 */
public class Main {

  private static final int BOT = 0, LEFT = 1, TOP = 2, RIGHT = 3;
  int n, m;
  int[][][] dp;
  char[][] arr;
  int[][][] last;
  int current;

  void solve(InputReader in, PrintWriter out) {
    n = in.nextInt();
    m = in.nextInt();
    arr = new char[n][];
    dp = new int[n][m][4];
    last = new int[n][m][4];

    for (int i = 0; i < n; ++i) {
      arr[i] = in.next().toCharArray();
      for (int j = 0; j < m; ++j)
        Arrays.fill(dp[i][j], -1);
    }

    int ans = 0;
    current = 1;
    for (int i = 0; i < n; ++i) {
      for (int j = 0; j < m; ++j) if (arr[i][j] == '.') {
        int count = 0;

        for (int dir = 0; dir < 4; ++dir) {
          int toAdd = solve(i, j, dir);

          count += toAdd;
        }
        ans = Math.max(ans, count);
        ++current;
      }
    }

    out.println(ans);

  }

  public int solve(int i, int j, int dir) {

    if (i < 0 || j < 0 || i >= n || j >=m) return 0;
    
    if (last[i][j][dir] == current) return 0;
    int toAdd = 1;
    for (int x = 0; x < 4; ++x) {
      if (last[i][j][x] == current) {
        toAdd = 0;
        break;
      }
    }

    last[i][j][dir] = current;

    if (dp[i][j][dir] >= 1) {
      return dp[i][j][dir] - (toAdd == 0 ? 1 : 0);
    }

    
    int ret = 0;
    if (arr[i][j] == '#') return dp[i][j][dir] = 0;
    else if (arr[i][j] == '\\') {
      if (dir == BOT) ret = solve(j + 1, i, RIGHT);
      else if (dir == LEFT) ret = solve(i - 1, j, TOP);
      else if (dir == RIGHT) ret = solve(i + 1, j, BOT);
      else ret = solve(i, j - 1, LEFT);
    } else if (arr[i][j] == '/') {
      if (dir == BOT) ret = solve(i, j - 1, LEFT);
      else if (dir == LEFT) ret = solve(i + 1, j, BOT);
      else if (dir == RIGHT) ret = solve(i - 1, j, TOP);
      else ret = solve(i, j + 1, RIGHT);
    } else {
      if (dir == BOT) ret = solve(i + 1, j, dir);
      else if (dir == TOP) ret = solve(i - 1, j, dir);
      else if (dir == RIGHT) ret = solve(i, j + 1, dir);
      else ret = solve(i, j - 1, dir);
      ret += toAdd;
    }

    return dp[i][j][dir] = ret;
  }

  public static void main(String[] args) {
    InputReader in = new InputReader(System.in);
    try (PrintWriter out = new PrintWriter(System.out)) {
      new Main().solve(in, out);
    }
  }
}

class InputReader  {

  private InputStream stream;
  private static final int DEFAULT_BUFFER_SIZE = 1 << 16;
  private static final int EOF = -1;
  private byte[] buf = new byte[DEFAULT_BUFFER_SIZE];
  private int curChar;
  private int numChars;

  public InputReader(InputStream stream) {
    this.stream = stream;
  }

  public int[] readIntArray(int tokens) {
    int[] ret = new int[tokens];
    for (int i = 0; i < tokens; i++) {
      ret[i] = nextInt();
    }
    return ret;
  }

  public int read() {
    if (this.numChars == EOF) {
      throw new UnknownError();
    } else {
      if (this.curChar >= this.numChars) {
        this.curChar = 0;

        try {
          this.numChars = this.stream.read(this.buf);
        } catch (IOException ex) {
          throw new InputMismatchException();
        }

        if (this.numChars <= 0) {
          return EOF;
        }
      }

      return this.buf[this.curChar++];
    }
  }

  public int nextInt() {
    int c;
    for (c = this.read(); isSpaceChar(c); c = this.read()) {
    }

    byte sgn = 1;
    if (c == 45) {
      sgn = -1;
      c = this.read();
    }

    int res = 0;

    while (c >= 48 && c <= 57) {
      res *= 10;
      res += c - 48;
      c = this.read();
      if (isSpaceChar(c)) {
        return res * sgn;
      }
    }

    throw new InputMismatchException();
  }

  public long nextLong() {
    int c;
    for (c = this.read(); isSpaceChar(c); c = this.read()) {
    }

    byte sgn = 1;
    if (c == 45) {
      sgn = -1;
      c = this.read();
    }

    long res = 0;

    while (c >= 48 && c <= 57) {
      res *= 10L;
      res += c - 48;
      c = this.read();
      if (isSpaceChar(c)) {
        return res * sgn;
      }
    }
    throw new InputMismatchException();
  }

  public double nextDouble() {
    double ret = 0, div = 1;
    int c = read();
    while (c <= ' ') {
      c = read();
    }
    boolean neg = (c == '-');
    if (neg) {
      c = read();
    }

    do {
      ret = ret * 10 + c - '0';
    }
    while ((c = read()) >= '0' && c <= '9');

    if (c == '.') {
      while ((c = read()) >= '0' && c <= '9') {
        ret += (c - '0') / (div *= 10);
      }
    }

    if (neg) {
      return -ret;
    }
    return ret;
  }

  public String next() {
    int c;
    while (isSpaceChar(c = this.read())) {
    }

    StringBuilder result = new StringBuilder();
    result.appendCodePoint(c);

    while (!isSpaceChar(c = this.read())) {
      result.appendCodePoint(c);
    }

    return result.toString();
  }

  public String nextLine() {
    int c;
    StringBuilder result = new StringBuilder();
    boolean read = false;
    while ((c = this.read()) != '\n') {
      if (c == -1) {
        return null;
      }
      result.appendCodePoint(c);
      read = true;
    }
    if (!read) {
      return null;
    }
    return result.toString();
  }

  public static boolean isSpaceChar(int c) {
    return c == 32 || c == 10 || c == 13 || c == 9 || c == EOF;
  }

  public int[] nextIntArray(int n) {
    int[] arr = new int[n];
    for (int i = 0; i < n; i++) {
      arr[i] = nextInt();
    }
    return arr;
  }

  public long[] nextLongArray(int n) {
    long[] arr = new long[n];
    for (int i = 0; i < n; i++) {
      arr[i] = nextLong();
    }
    return arr;
  }

  public int[][] nextIntMatrix(int n, int m) {
    int[][] arr = new int[n][m];
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        arr[i][j] = nextInt();
      }
    }
    return arr;
  }

  public long[][] nextLongMatrix(int n, int m) {
    long[][] arr = new long[n][m];
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        arr[i][j] = nextLong();
      }
    }
    return arr;
  }

  public char[] nextCharArray() {
    return next().toCharArray();
  }

  public double[] nextDoubleArray(int n) {
    double[] ret = new double[n];
    for (int i = 0; i < n; i++) {
      ret[i] = nextDouble();
    }
    return ret;
  }

  public int[]
  nextIntArrayOneBased(int n) {
    int[] ret = new int[n + 1];
    for (int i = 1; i <= n; i++) {
      ret[i] = nextInt();
    }
    return ret;
  }

  public char[][] nextCharMatrix(int n, int m) {
    char[][] res = new char[n][m];
    for (int i = 0; i < n; ++i) {
      res[i] = nextCharArray();
    }
    return res;
  }
}