Go: package main

import (
	"bufio"
	"encoding/json"
	"fmt"
	"os"
	"strconv"
	"strings"
)

var (
	sc = bufio.NewScanner(os.Stdin)
)

type Color int

const (
	ColorBlack Color = iota
	ColorRed
)

var strByColor = map[Color]string{
	ColorBlack: "black",
	ColorRed:   "red",
}

func (c Color) String() string {
	return strByColor[c]
}

type Node struct {
	ID      int
	X, Y    int
	Color   Color
	NextIDs map[int]struct{}
}

func (n *Node) String() string {
	d, _ := json.Marshal(n)
	return string(d)
}

type Map struct {
	Width, Height int
	Nodes         map[int]*Node
}

func (m *Map) GetByID(id int) *Node {
	return m.Nodes[id]
}

func (m *Map) Get(x, y int) *Node {
	return m.Nodes[m.getID(x, y)]
}

func (m *Map) SetColor(x, y int, c Color) {
	m.Nodes[m.getID(x, y)].Color = c
}

func (m *Map) getID(x, y int) int {
	return x + y*m.Width
}

func (m *Map) init() {
	for x := 1; x <= m.Width; x++ {
		for y := 1; y <= m.Height; y++ {
			id := m.getID(x, y)
			m.Nodes[id] = &Node{ID: id, X: x, Y: y}
		}
	}
	for x := 1; x <= m.Width; x++ {
		for y := 1; y <= m.Height; y++ {
			nextIDs := map[int]struct{}{}
			if x > 1 {
				nextIDs[m.getID(x-1, y)] = struct{}{}
			}
			if x < m.Width {
				nextIDs[m.getID(x+1, y)] = struct{}{}
			}
			if y > 1 {
				nextIDs[m.getID(x, y-1)] = struct{}{}
			}
			if y < m.Height {
				nextIDs[m.getID(x, y+1)] = struct{}{}
			}
			m.Get(x, y).NextIDs = nextIDs
		}
	}
}

func NewMap(w, h int) *Map {
	m := &Map{Width: w, Height: h, Nodes: map[int]*Node{}}
	m.init()
	return m
}

type Searcher struct {
	Map        *Map
	queue      []*Node
	touchedIDs map[int]struct{}
	visitedIDs map[int]struct{}
}

func NewSearcher(m *Map) *Searcher {
	return &Searcher{
		Map:        m,
		queue:      []*Node{},
		touchedIDs: map[int]struct{}{},
		visitedIDs: map[int]struct{}{},
	}
}

func (s *Searcher) Search(start *Node) {
	s.enqueue(start)

	for {
		if len(s.queue) == 0 {
			break
		}
		for nextID := range s.dequeue().NextIDs {
			n := s.Map.GetByID(nextID)
			if n.Color == ColorRed || s.hasTouched(n) {
				continue
			}
			s.enqueue(n)
		}
	}
}

func (s *Searcher) VisitedNodeCount() int {
	return len(s.visitedIDs)
}

func (s *Searcher) hasTouched(n *Node) bool {
	_, ok := s.touchedIDs[n.ID]
	return ok
}

func (s *Searcher) enqueue(n *Node) {
	s.queue = append(s.queue, n)
	s.touchedIDs[n.ID] = struct{}{}
}

func (s *Searcher) dequeue() *Node {
	n := s.queue[0]
	s.queue = s.queue[1:]
	s.visitedIDs[n.ID] = struct{}{}
	return n
}

func main() {
	for sc.Scan() {
		if sc.Text() == "0 0" {
			break
		}
		chunks := strings.Split(sc.Text(), " ")
		w, _ := strconv.Atoi(chunks[0])
		h, _ := strconv.Atoi(chunks[1])

		m := NewMap(w, h)

		// Set colors
		var start *Node
		for y := 1; y <= h; y++ {
			sc.Scan()
			for i, c := range sc.Text() {
				switch c {
				case '.', '@':
					m.SetColor(i+1, y, ColorBlack)
					if c == '@' {
						start = m.Get(i+1, y)
					}
				case '#':
					m.SetColor(i+1, y, ColorRed)
				}
			}
		}

		// Search
		s := NewSearcher(m)
		s.Search(start)
		fmt.Println(s.VisitedNodeCount())
	}
}

Python: while True:
    w, h = map(int, input().split())
    if w == 0 and h == 0:
        break
    m = []
    for _ in range(h):
        m.append(list(input()))
    visited = [[False] * w for _ in range(h)]
    dxy = [(1, 0), (0, 1), (-1, 0), (0, -1)]
    answer = 0


    def rec(x, y):
        global answer
        visited[x][y] = True
        answer += 1
        for (dx, dy) in dxy:  # 4方向の移動を試す
            x2 = x + dx
            y2 = y + dy
            if 0 <= x2 < h and 0 <= y2 < w:
                if m[x2][y2] == '.':
                    if not visited[x2][y2]:
                        rec(x2, y2)  # 再帰呼び出し


    for i in range(h):
        for j in range(w):
            if m[i][j] == '@':
                rec(i, j)
                break
        else:
            continue
        break
    print(answer)

Python: # -*- coding: utf-8 -*-
#rea and blac
h,w=1,1

count=0

def search(x,y):
    #マップの外側か壁の場合は何もしない
    #print(x,y)
    global count
    if x<0 or x>w-1 or y<0 or y>h-1 or map_data[y][x]=='#':
 
        return
        
    
    #以前に到達していたら何もしない
    if reached[y][x]:
         return

    reached[y][x]=1
    count+=1
    #print("aa")



    search(x+1,y)#右
    search(x-1,y)#左
    search(x,y+1)#上
    search(x,y-1)#下
    



while h!=0 and w!=0: 

    count=0
    #グラフの入力方法------

    w,h=map(int ,raw_input().split())
    if h==0 and w==0:
        break

    map_data = [[0]*w for _ in range(h)]
    reached = [[0]*w for _ in range(h)]
    for i in range(h):
        ct = raw_input()
        #print(len(ct))
        for j in range(w):
            map_data[i][j] = ct[j]
            if ct[j]=="@":
                sx=j
                sy=i

    #------



    search(sx,sy)

    print(count)
    count=0
    w=1
    h=1

Python: from queue import *


d = [(1,0),(0,1),(-1,0),(0,-1)]
temp={}

while True:
    W,H = (int(x) for x in input().split())
    mmap=[]
    visited=[]
    flag=0
    count=1
    
    q = Queue()
    
    if W==0 & H==0:
        break
    for i in range(0,H):
        mmap.append(list(input()))
    for i in range (0,H):
        for j in range(0,W):
            if mmap[i][j] == '@':
                start=[i,j]
    
    q.put(start)
    visited.append(list(start))
    while not q.empty():
        now = q.get()
        for myd in d:
            now2 = list(now)
            now2[0] += myd[0]
            now2[1] += myd[1]
            if not(now2[0]==-1 or now2[0]==H or now2[1]==-1 or now2[1]==W) :
                if mmap[now2[0]][now2[1]] != '#' :
                    flag=0
                    for v in visited:
                        if now2 == v :
                            flag=1
                            break
                    if flag==0:
                        count+=1
                        q.put(now2)
                        visited.append(list(now2))
    
    print(count)

Python: def dfs(now,origin,drawn): # 深さ優先探索　再帰関数　originは変更しない　drawnは訪れた場所に1それ以外は0
    positive = '.' # 進める場所
    negative = '#' # 進めない場所(壁)
    direct = [0,0,0,0] # [上,下,左,右]を表す
    height = len(origin)
    width = len(origin[0])
    now_h = now[0]
    now_w = now[1]
    ### それぞれの方向について、originにおいてpositiveかつdrawnにおいて0（つまり訪れたことがある）なら進める
    if now_h != 0 and origin[now_h-1][now_w] == positive and drawn[now_h-1][now_w] == 0:
        direct[0] = 1
    if now_h != height-1 and origin[now_h+1][now_w] == positive and drawn[now_h+1][now_w] == 0:
        direct[1] = 1
    if now_w != 0 and origin[now_h][now_w-1] == positive and drawn[now_h][now_w-1] == 0:
        direct[2] = 1
    if now_w != width-1 and origin[now_h][now_w+1] == positive and drawn[now_h][now_w+1] == 0:
        direct[3] = 1

    if sum(direct) == 0: # 進む先がなければ終了
        return 0
    d = {0:[now_h-1,now_w],1:[now_h+1,now_w],2:[now_h,now_w-1],3:[now_h,now_w+1]} # 進む先の座標を辞書にしておく
    for i in range(4):
        if direct[i] == 1:
            drawn[d[i][0]][d[i][1]] = 1 # d[i]の座標に移動したのでdrawnで訪れたことを記録した
            dfs(d[i],origin,drawn) # 再帰
    return 0

while True:
    W, H = map(int,input().split()) # 入力を受け取る
    if W == 0 and H == 0: # 両方0だったらbreak
        break
    tiles = [list(input()) for i in range(H)] # 入力
    possible_tiles = [[0 for i in range(W)] for j in range(H)] # 訪れたことがある場所を記憶する
    for h in range(H):
        for w in range(W):
            if tiles[h][w] == '@': # 現在地
                now = [h,w]
                break
    possible_tiles[now[0]][now[1]] = 1 # 現在地は既に訪れている
    dfs(now,tiles,possible_tiles) # 探索
    ans = 0
    for h in range(H):
        for w in range(W):
            if possible_tiles[h][w] == 1:
                ans += 1
    print(ans)